Cómo registrar MethodName al ajustar Log4net?

Question

he envuelto en un envoltorio Log4net estática y desea iniciar sesión

loggingEvent.LocationInformation.MethodName 
loggingEvent.LocationInformation.ClassName 

Sin embargo, todo lo que consigo es el nombre de mi envoltura.

¿Cómo puedo registrar esa información utilizando un forwardingappender y una clase de contenedor estático como

Logger.Debug("Logging to Debug"); 
Logger.Info("Logging to Info"); 
Logger.Warn("Logging to Warn"); 
Logger.Error(ex); 
Logger.Fatal(ex); 

Answer 1

bien el error fue en algún lugar de mi appender sino por la totalidad enfermos incluyen la respuesta a lo mejor de mi conocimiento:

la fachada que necesita debe envolver ILogger y NO ILOG

public static class Logger 
{ 
    private readonly static Type ThisDeclaringType = typeof(Logger); 
    private static readonly ILogger defaultLogger; 

    static Logger() 
    { 
     defaultLogger = 
     LoggerManager.GetLogger(Assembly.GetCallingAssembly(),"MyDefaultLoggger"); 

...

public static void Info(string message) 
    { 
     if (defaultLogger.IsEnabledFor(infoLevel)) 
     { 
      defaultLogger.Log(typeof(Logger), infoLevel, message, null); 
     } 
    } 

Answer 2

La única cosa que puedo pensar en hacer (como yo no utilizan actualmente log4net) es solicitar una StackTrace (nueva StackTrace), y retroceda un marco para obtener la información que necesita. Sin embargo, no estoy seguro del impacto en el rendimiento del tiempo de ejecución de esto.

Answer 3

Sólo declarar la variable de registro así ...

private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); 

Entonces puede usarlo normalmente.

Answer 4

Este post me ayudó a encontrar la manera de escribir mi propio envoltorio, a cambio, pensé que podría gustarle mi clase completa para envolver el registrador que parece funcionar muy bien y que realmente lleva más de la mitad del tiempo que usar un ILog ¡directamente!

Todo lo que se necesita es el XML adecuado para configurar el registro en el fichero de configuración y

[assembly: log4net.Config.XmlConfigurator(Watch = true)] 

en sus AssemblyInfo.cs y debería funcionar fácilmente.

Una nota: Estoy usando Log4NetDash con una configuración muy simple, así que he estafado y puesto algo de información en los campos incorrectos (por ejemplo, seguimiento de pila en el campo Dominio), esto todavía funciona para mí ya que no me importa donde se muestra la información, pero es posible que desee corregir esto si está configurando cosas correctamente si tiene tiempo libre.

using System; 
using System.ComponentModel; 
using System.Diagnostics; 
using System.Reflection; 
using System.Threading; 
using log4net; 
using log4net.Core; 

namespace Utility 
{ 
    public class Logger 
    { 
     static Logger() 
     { 
      LogManager.GetLogger(typeof(Logger)); 
     } 

     public static void Debug(string message, params object[] parameters) 
     { 
      Log(message, Level.Debug, null, parameters); 
     } 

     public static void Info(string message, params object[] parameters) 
     { 
      Log(message, Level.Info, null, parameters); 
     } 

     public static void Warn(string message, params object[] parameters) 
     { 
      Log(message, Level.Warn, null, parameters); 
     } 

     public static void Error(string message, params object[] parameters) 
     { 
      Error(message, null, parameters); 
     } 

     public static void Error(Exception exception) 
     { 
      if (exception==null) 
       return; 
      Error(exception.Message, exception); 
     } 

     public static void Error(string message, Exception exception, params object[] parameters) 
     { 
      string exceptionStack = ""; 

      if (exception != null) 
      { 
       exceptionStack = exception.GetType().Name + " : " + exception.Message + Environment.NewLine; 
       Exception loopException = exception; 
       while (loopException.InnerException != null) 
       { 
        loopException = loopException.InnerException; 
        exceptionStack += loopException.GetType().Name + " : " + loopException.Message + Environment.NewLine; 
       } 
      } 

      Log(message, Level.Error, exceptionStack, parameters); 
     } 



     private static void Log(string message, Level logLevel, string exceptionMessage, params object[] parameters) 
     { 
      BackgroundWorker worker = new BackgroundWorker(); 
      worker.DoWork += LogEvent; 
      worker.RunWorkerAsync(new LogMessageSpec 
             { 
              ExceptionMessage = exceptionMessage, 
              LogLevel = logLevel, 
              Message = message, 
              Parameters = parameters, 
              Stack = new StackTrace(), 
              LogTime = DateTime.Now 
             }); 
     } 

     private static void LogEvent(object sender, DoWorkEventArgs e) 
     { 
      try 
      { 
       LogMessageSpec messageSpec = (LogMessageSpec) e.Argument; 

       StackFrame frame = messageSpec.Stack.GetFrame(2); 
       MethodBase method = frame.GetMethod(); 
       Type reflectedType = method.ReflectedType; 

       ILogger log = LoggerManager.GetLogger(reflectedType.Assembly, reflectedType); 
       Level currenLoggingLevel = ((log4net.Repository.Hierarchy.Logger) log).Parent.Level; 

       if (messageSpec.LogLevel<currenLoggingLevel) 
        return; 

       messageSpec.Message = string.Format(messageSpec.Message, messageSpec.Parameters); 
       string stackTrace = ""; 
       StackFrame[] frames = messageSpec.Stack.GetFrames(); 
       if (frames != null) 
       { 
        foreach (StackFrame tempFrame in frames) 
        { 

         MethodBase tempMethod = tempFrame.GetMethod(); 
         stackTrace += tempMethod.Name + Environment.NewLine; 
        } 
       } 
       string userName = Thread.CurrentPrincipal.Identity.Name; 
       LoggingEventData evdat = new LoggingEventData 
              { 
               Domain = stackTrace, 
               Identity = userName, 
               Level = messageSpec.LogLevel, 
               LocationInfo = new LocationInfo(reflectedType.FullName, 
                       method.Name, 
                       frame.GetFileName(), 
                       frame.GetFileLineNumber().ToString()), 
               LoggerName = reflectedType.Name, 
               Message = messageSpec.Message, 
               TimeStamp = messageSpec.LogTime, 
               UserName = userName, 
               ExceptionString = messageSpec.ExceptionMessage 
              }; 
       log.Log(new LoggingEvent(evdat)); 
      } 
      catch (Exception) 
      {}//don't throw exceptions on background thread especially about logging! 
     } 

     private class LogMessageSpec 
     { 
      public StackTrace Stack { get; set; } 
      public string Message { get; set; } 
      public Level LogLevel { get; set; } 
      public string ExceptionMessage { get; set; } 
      public object[] Parameters { get; set; } 
      public DateTime LogTime { get; set; } 
     } 
    } 
} 

Answer 5

¿Qué pasa con las variables %M y %C? http://logging.apache.org/log4net/release/sdk/log4net.Layout.PatternLayout.html

uso, algo así como:

<layout type="log4net.Layout.PatternLayout"> 
    <conversionPattern value="%date [%thread] %-5level %logger [%M %C] - %message%newline" /> 
</layout> 

¿Eso no hacen lo que está después?

Answer 6

¿Qué hay de C# 4.5 función CallerInfo - http://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.callermembernameattribute.aspx

Answer 7

yo simplemente usar algo como %stacktrace{2} como un patrón de conversión.

Ejemplo de salida:

MyNamespace.ClassName.Método> Common.Log.Warning

donde MyNamespace.ClassName.Method es un método que está llamando mi envoltura y Common.Log.Warning es un método de la clase contenedora.

Los patrones de conversión se pueden encontrar here.

Answer 8

sólo voy a escribir más código de la respuesta correcta de Noel

En la clase contenedora

public static class Logger 
{ 
    private static readonly ILogger DefaultLogger; 

    static Logger() 
    { 
     defaultLogger = LoggerManager.GetLogger(Assembly.GetCallingAssembly(), "MyDefaultLoggger"); // MyDefaultLoggger is the name of Logger 
    } 

    public static void LogError(object message) 
    { 
     Level errorLevel = Level.Error; 
     if (DefaultLogger.IsEnabledFor(errorLevel)) 
     { 
      DefaultLogger.Log(typeof(Logger), errorLevel, message, null); 
     } 
    } 

    public static void LogError(object message, Exception exception) 
    { 
     Level errorLevel = Level.Error; 
     if (DefaultLogger.IsEnabledFor(errorLevel)) 
     { 
      DefaultLogger.Log(typeof(Logger), errorLevel, message, exception); 
     } 
    } 

y así sucesivamente para el resto de los métodos.

en web.config o app.config log4net.Layout.PatternLayout puede utilizar algunos patrones de conversión como:

%location %method %line 

<layout type="log4net.Layout.PatternLayout"> 
    <conversionPattern value="%date{dd/MM/yyyy hh:mm:ss.fff tt} [%thread] %level %logger [%location %method %line] [%C %M] - %newline%message%newline%exception"/> 
    </layout>