| public SetStackTrace ( Windows.Adapters.StackTrace stackTrace, int userStackFrame ) : void | ||
| stackTrace | Windows.Adapters.StackTrace | The stack trace. |
| userStackFrame | int | Index of the first user stack frame within the stack trace. |
| return | void | |
private void ProcessLogEventInfo(LogLevel logLevel, string loggerName, [Localizable(false)] string message, object[] arguments, int?eventId)
{
var ev = new LogEventInfo();
ev.LoggerName = (loggerName ?? this.Name) ?? string.Empty;
#if !NET_CF
if (this.AutoLoggerName)
{
var stack = new StackTrace();
int userFrameIndex = -1;
MethodBase userMethod = null;
for (int i = 0; i < stack.FrameCount; ++i)
{
var frame = stack.GetFrame(i);
var method = frame.GetMethod();
if (method.DeclaringType == this.GetType())
{
// skip all methods of this type
continue;
}
if (method.DeclaringType.Assembly == systemAssembly)
{
// skip all methods from System.dll
continue;
}
userFrameIndex = i;
userMethod = method;
break;
}
if (userFrameIndex >= 0)
{
ev.SetStackTrace(stack, userFrameIndex);
if (userMethod.DeclaringType != null)
{
ev.LoggerName = userMethod.DeclaringType.FullName;
}
}
}
#endif
ev.TimeStamp = CurrentTimeGetter.Now;
ev.Message = message;
ev.Parameters = arguments;
ev.Level = this.forceLogLevel ?? logLevel;
if (eventId.HasValue)
{
ev.Properties.Add("EventID", eventId.Value);
}
Logger logger = LogManager.GetLogger(ev.LoggerName);
logger.Log(ev);
}
public static void Fatal(Exception ex, string module)
{
lock (_sync)
{
var log = ServiceLocator.Current.GetInstance <ILogger>();
var e = new NLog.LogEventInfo();
e.Level = LogLevel.Fatal;
e.Exception = ex;
e.Properties["module"] = module;
e.SetStackTrace(new StackTrace(), 1);
log.Log(e);
}
}
internal static void Write(Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
{
if (targets == null)
{
return;
}
#if !NET_CF
StackTraceUsage stu = targets.GetStackTraceUsage();
if (stu != StackTraceUsage.None && !logEvent.HasStackTrace)
{
StackTrace stackTrace;
#if !SILVERLIGHT
stackTrace = new StackTrace(StackTraceSkipMethods, stu == StackTraceUsage.WithSource);
#else
stackTrace = new StackTrace();
#endif
int firstUserFrame = FindCallingMethodOnStackTrace(stackTrace, loggerType);
logEvent.SetStackTrace(stackTrace, firstUserFrame);
}
#endif
int originalThreadId = Thread.CurrentThread.ManagedThreadId;
AsyncContinuation exceptionHandler = ex =>
{
if (ex != null)
{
if (factory.ThrowExceptions && Thread.CurrentThread.ManagedThreadId == originalThreadId)
{
throw new NLogRuntimeException("Exception occurred in NLog", ex);
}
}
};
for (var t = targets; t != null; t = t.NextInChain)
{
if (!WriteToTargetWithFilterChain(t, logEvent, exceptionHandler))
{
break;
}
}
// Destroy the objects
logEvent.Dispose();
}
internal static void Write([NotNull] Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
{
if (targets == null)
{
return;
}
StackTraceUsage stu = targets.GetStackTraceUsage();
if (stu != StackTraceUsage.None && !logEvent.HasStackTrace)
{
StackTrace stackTrace;
#if NETSTANDARD1_5
stackTrace = (StackTrace)Activator.CreateInstance(typeof(StackTrace), new object[] { stu == StackTraceUsage.WithSource });
#elif !SILVERLIGHT
stackTrace = new StackTrace(StackTraceSkipMethods, stu == StackTraceUsage.WithSource);
#else
stackTrace = new StackTrace();
#endif
int firstUserFrame = FindCallingMethodOnStackTrace(stackTrace, loggerType);
logEvent.SetStackTrace(stackTrace, firstUserFrame);
}
AsyncContinuation exceptionHandler = (ex) => { };
if (factory.ThrowExceptions)
{
int originalThreadId = Thread.CurrentThread.ManagedThreadId;
exceptionHandler = ex =>
{
if (ex != null)
{
if (Thread.CurrentThread.ManagedThreadId == originalThreadId)
{
throw new NLogRuntimeException("Exception occurred in NLog", ex);
}
}
};
}
for (var t = targets; t != null; t = t.NextInChain)
{
if (!WriteToTargetWithFilterChain(t, logEvent, exceptionHandler))
{
break;
}
}
}
internal static void Write(Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
{
InternalLogger.Trace("Writing event {0} {1} {2}", logEvent.LoggerName, logEvent.Level, logEvent.Message);
if (targets == null)
{
return;
}
StackTraceUsage stu = targets.GetStackTraceUsage();
if (stu != StackTraceUsage.None && !logEvent.HasStackTrace)
{
StackTrace stackTrace;
#if !SILVERLIGHT
stackTrace = new StackTrace(StackTraceSkipMethods, stu == StackTraceUsage.WithSource);
#else
stackTrace = new StackTrace();
#endif
int firstUserFrame = FindCallingMethodOnStackTrace(stackTrace, loggerType);
logEvent.SetStackTrace(stackTrace, firstUserFrame);
}
int originalThreadId = Thread.CurrentThread.ManagedThreadId;
AsyncContinuation exceptionHandler = ex =>
{
if (ex != null)
{
if (factory.ThrowExceptions && Thread.CurrentThread.ManagedThreadId == originalThreadId)
{
throw new NLogRuntimeException("Exception occurred in NLog", ex);
}
}
};
for (var t = targets; t != null; t = t.NextInChain)
{
InternalLogger.Trace("Writing to logger {0}", t.Target.Name);
if (!WriteToTargetWithFilterChain(t, logEvent, exceptionHandler))
{
break;
}
}
}
/// <summary>
/// Process the log event
/// <param name="logLevel">The log level.</param>
/// <param name="loggerName">The name of the logger.</param>
/// <param name="message">The log message.</param>
/// <param name="arguments">The log parameters.</param>
/// <param name="eventId">The event id.</param>
/// <param name="eventType">The event type.</param>
/// <param name="relatedActiviyId">The related activity id.</param>
/// </summary>
protected virtual void ProcessLogEventInfo(LogLevel logLevel, string loggerName, [Localizable(false)] string message, object[] arguments, int?eventId, TraceEventType?eventType, Guid?relatedActiviyId)
{
StackTrace stackTrace = AutoLoggerName ? new StackTrace() : null;
ILogger logger = GetLogger(loggerName, stackTrace, out int userFrameIndex);
logLevel = _forceLogLevel ?? logLevel;
if (!logger.IsEnabled(logLevel))
{
return; // We are done
}
var ev = new LogEventInfo();
ev.LoggerName = logger.Name;
ev.Level = logLevel;
if (eventType.HasValue)
{
ev.Properties.Add("EventType", eventType.Value);
}
if (relatedActiviyId.HasValue)
{
ev.Properties.Add("RelatedActivityID", relatedActiviyId.Value);
}
ev.Message = message;
ev.Parameters = arguments;
ev.Level = _forceLogLevel ?? logLevel;
if (eventId.HasValue)
{
ev.Properties.Add("EventID", eventId.Value);
}
if (stackTrace != null && userFrameIndex >= 0)
{
ev.SetStackTrace(stackTrace, userFrameIndex);
}
logger.Log(ev);
}
internal static void Write(Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
{
if (targets == null)
return;
#if !NETCF
bool needTrace = false;
bool needTraceSources = false;
int nst = targets.NeedsStackTrace;
if (nst > 0)
needTrace = true;
if (nst > 1)
needTraceSources = true;
StackTrace stackTrace = null;
if (needTrace && !logEvent.HasStackTrace)
{
int firstUserFrame = 0;
stackTrace = new StackTrace(STACK_TRACE_SKIP_METHODS, needTraceSources);
for (int i = 0; i < stackTrace.FrameCount; ++i)
{
System.Reflection.MethodBase mb = stackTrace.GetFrame(i).GetMethod();
if (mb.DeclaringType == loggerType)
{
firstUserFrame = i + 1;
}
else
{
if (firstUserFrame != 0)
break;
}
}
logEvent.SetStackTrace(stackTrace, firstUserFrame);
}
#endif
for (TargetWithFilterChain awf = targets; awf != null; awf = awf.Next)
{
Target app = awf.Target;
FilterResult result = FilterResult.Neutral;
try
{
FilterCollection filterChain = awf.FilterChain;
for (int i = 0; i < filterChain.Count; ++i)
{
Filter f = filterChain[i];
result = f.Check(logEvent);
if (result != FilterResult.Neutral)
break;
}
if ((result == FilterResult.Ignore) || (result == FilterResult.IgnoreFinal))
{
if (InternalLogger.IsDebugEnabled)
{
InternalLogger.Debug("{0}.{1} Rejecting message because of a filter.", logEvent.LoggerName, logEvent.Level);
}
if (result == FilterResult.IgnoreFinal)
return;
continue;
}
}
catch (Exception ex)
{
InternalLogger.Error("FilterChain exception: {0}", ex);
if (factory.ThrowExceptions)
throw;
else
continue;
}
try
{
app.Write(logEvent);
}
catch (Exception ex)
{
InternalLogger.Error("Target exception: {0}", ex);
if (factory.ThrowExceptions)
throw;
else
continue;
}
if (result == FilterResult.LogFinal)
return;
}
}
protected virtual void ProcessLogEventInfo(LogLevel logLevel, string loggerName, [Localizable(false)] string message, object[] arguments, int? eventId)
#endif
{
var ev = new LogEventInfo();
ev.LoggerName = (loggerName ?? this.Name) ?? string.Empty;
#if !NET_CF
if (this.AutoLoggerName)
{
var stack = new StackTrace();
int userFrameIndex = -1;
MethodBase userMethod = null;
for (int i = 0; i < stack.FrameCount; ++i)
{
var frame = stack.GetFrame(i);
var method = frame.GetMethod();
if (method.DeclaringType == this.GetType())
{
// skip all methods of this type
continue;
}
if (method.DeclaringType.Assembly == systemAssembly)
{
// skip all methods from System.dll
continue;
}
userFrameIndex = i;
userMethod = method;
break;
}
if (userFrameIndex >= 0)
{
ev.SetStackTrace(stack, userFrameIndex);
if (userMethod.DeclaringType != null)
{
ev.LoggerName = userMethod.DeclaringType.FullName;
}
}
}
if (eventType.HasValue)
{
ev.Properties.Add("EventType", eventType.Value);
}
if (relatedActiviyId.HasValue)
{
ev.Properties.Add("RelatedActivityID", relatedActiviyId.Value);
}
#endif
ev.TimeStamp = TimeSource.Current.Time;
ev.Message = message;
ev.Parameters = arguments;
ev.Level = this.forceLogLevel ?? logLevel;
if (eventId.HasValue)
{
ev.Properties.Add("EventID", eventId.Value);
}
Logger logger;
if (this.LogFactory != null)
{
logger = this.LogFactory.GetLogger(ev.LoggerName);
}
else
{
logger = LogManager.GetLogger(ev.LoggerName);
}
logger.Log(ev);
}
internal static void Write(Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
{
if (targets == null)
{
return;
}
#if !NETCF
bool needTrace = false;
bool needTraceSources = false;
int nst = targets.NeedsStackTrace;
if (nst > 0)
{
needTrace = true;
}
if (nst > 1)
{
needTraceSources = true;
}
StackTrace stackTrace = null;
if (needTrace && !logEvent.HasStackTrace)
{
int firstUserFrame = 0;
stackTrace = new StackTrace(STACK_TRACE_SKIP_METHODS, needTraceSources);
for (int i = 0; i < stackTrace.FrameCount; ++i)
{
System.Reflection.MethodBase mb = stackTrace.GetFrame(i).GetMethod();
if (mb.DeclaringType == loggerType)
{
firstUserFrame = i + 1;
}
else
{
if (firstUserFrame != 0)
{
break;
}
}
}
logEvent.SetStackTrace(stackTrace, firstUserFrame);
}
#endif
for (TargetWithFilterChain awf = targets; awf != null; awf = awf.Next)
{
Target app = awf.Target;
FilterResult result = FilterResult.Neutral;
try
{
FilterCollection filterChain = awf.FilterChain;
for (int i = 0; i < filterChain.Count; ++i)
{
Filter f = filterChain[i];
result = f.Check(logEvent);
if (result != FilterResult.Neutral)
{
break;
}
}
if ((result == FilterResult.Ignore) || (result == FilterResult.IgnoreFinal))
{
if (InternalLogger.IsDebugEnabled)
{
InternalLogger.Debug("{0}.{1} Rejecting message because of a filter.", logEvent.LoggerName, logEvent.Level);
}
if (result == FilterResult.IgnoreFinal)
{
return;
}
continue;
}
}
catch (Exception ex)
{
InternalLogger.Error("FilterChain exception: {0}", ex);
if (factory.ThrowExceptions)
{
throw;
}
else
{
continue;
}
}
try
{
app.Write(logEvent);
}
catch (Exception ex)
{
InternalLogger.Error("Target exception: {0}", ex);
if (factory.ThrowExceptions)
{
throw;
}
else
{
continue;
}
}
if (result == FilterResult.LogFinal)
{
return;
}
}
}
/// <summary>
/// Process the log event
/// <param name="logLevel">The log level.</param>
/// <param name="loggerName">The name of the logger.</param>
/// <param name="message">The log message.</param>
/// <param name="arguments">The log parameters.</param>
/// <param name="eventId">The event id.</param>
/// <param name="eventType">The event type.</param>
/// <param name="relatedActiviyId">The related activity id.</param>
/// </summary>
protected virtual void ProcessLogEventInfo(LogLevel logLevel, string loggerName, [Localizable(false)] string message, object[] arguments, int?eventId, TraceEventType?eventType, Guid?relatedActiviyId)
{
loggerName = (loggerName ?? Name) ?? string.Empty;
StackTrace stackTrace = null;
int userFrameIndex = -1;
if (AutoLoggerName)
{
stackTrace = new StackTrace();
MethodBase userMethod = null;
for (int i = 0; i < stackTrace.FrameCount; ++i)
{
var frame = stackTrace.GetFrame(i);
var method = frame.GetMethod();
if (method.DeclaringType == GetType())
{
// skip all methods of this type
continue;
}
if (method.DeclaringType != null && method.DeclaringType.Assembly == systemAssembly)
{
// skip all methods from System.dll
continue;
}
userFrameIndex = i;
userMethod = method;
break;
}
if (userFrameIndex >= 0)
{
if (userMethod != null && userMethod.DeclaringType != null)
{
loggerName = userMethod.DeclaringType.FullName;
}
}
}
ILogger logger;
if (LogFactory != null)
{
logger = LogFactory.GetLogger(loggerName);
}
else
{
logger = LogManager.GetLogger(loggerName);
}
logLevel = _forceLogLevel ?? logLevel;
if (!logger.IsEnabled(logLevel))
{
return; // We are done
}
var ev = new LogEventInfo();
ev.LoggerName = loggerName;
ev.Level = logLevel;
if (eventType.HasValue)
{
ev.Properties.Add("EventType", eventType.Value);
}
if (relatedActiviyId.HasValue)
{
ev.Properties.Add("RelatedActivityID", relatedActiviyId.Value);
}
ev.Message = message;
ev.Parameters = arguments;
ev.Level = _forceLogLevel ?? logLevel;
if (eventId.HasValue)
{
ev.Properties.Add("EventID", eventId.Value);
}
if (stackTrace != null && userFrameIndex >= 0)
{
ev.SetStackTrace(stackTrace, userFrameIndex);
}
logger.Log(ev);
}
public void Log(LoggingData loggingData)
{
var logEvent = new LogEventInfo();
logEvent.LoggerName = loggingData.LoggerName;
logEvent.Message = loggingData.Message;
logEvent.TimeStamp = loggingData.TimeStamp;
if (!string.IsNullOrEmpty(loggingData.ExceptionString))
logEvent.Exception = new Exception(loggingData.ExceptionString);
if (loggingData.Properties != null && loggingData.Properties.Count > 0)
{
var properties = loggingData.Properties;
var dict = new Dictionary<object, object>();
foreach(var k in properties.Keys.OfType<string>())
{
properties.Add(k, properties[k]);
}
}
if(loggingData.LocationInfo != null)
{
var locationInfo = loggingData.LocationInfo;
var lineNumber = 0;
int.TryParse(locationInfo.LineNumber, out lineNumber);
logEvent.SetStackTrace(new StackTrace(new StackFrame(locationInfo.FileName, lineNumber)), 0);
}
LogLevel level;
if (!s_LevelDict.TryGetValue(loggingData.Level, out level))
level = LogLevel.Info;
logEvent.Level = level;
m_Logger.Log(logEvent);
}
internal static void Write([NotNull] Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
{
if (targets == null)
{
return;
}
StackTraceUsage stu = targets.GetStackTraceUsage();
if (stu != StackTraceUsage.None && !logEvent.HasStackTrace)
{
StackTrace stackTrace;
#if !SILVERLIGHT
stackTrace = new StackTrace(StackTraceSkipMethods, stu == StackTraceUsage.WithSource);
#else
stackTrace = new StackTrace();
#endif
int firstUserFrame = FindCallingMethodOnStackTrace(stackTrace, loggerType);
logEvent.SetStackTrace(stackTrace, firstUserFrame);
}
ExceptionHandlerContinuation handler;
int numberOfTargets = 0;
for (var t = targets; t != null; t = t.NextInChain)
{
FilterResult result = GetFilterResult(t.FilterChain, logEvent);
if ((result == FilterResult.Ignore) || (result == FilterResult.IgnoreFinal))
{
if (InternalLogger.IsDebugEnabled)
{
InternalLogger.Debug(
"{0}.{1} Rejecting message because of a filter.",
logEvent.LoggerName,
logEvent.Level);
}
if (result == FilterResult.IgnoreFinal)
{
break;
}
}
else
{
numberOfTargets += 1;
}
}
if (factory.Configuration.PoolingEnabled())
{
handler = factory.Configuration.PoolFactory.Get <ExceptionHandlerPool, ExceptionHandlerContinuation>().Get(Thread.CurrentThread.ManagedThreadId, factory.ThrowExceptions);
}
else
{
handler = new ExceptionHandlerContinuation(Thread.CurrentThread.ManagedThreadId, factory.ThrowExceptions);
}
bool clone = numberOfTargets > 1;
// Clone a message for each target, so that each target can put it back into the pool when its done with it.
for (var t = targets; t != null; t = t.NextInChain)
{
if (!WriteToTargetWithFilterChain(t, logEvent, handler.Delegate, clone))
{
break;
}
}
// No targets at all wanted this log event, so put it back into the pool
if (numberOfTargets == 0 || clone)
{
logEvent.PutBack();
}
}
/// <summary>
/// Process the log event
/// <param name="logLevel">The log level.</param>
/// <param name="loggerName">The name of the logger.</param>
/// <param name="message">The log message.</param>
/// <param name="arguments">The log parameters.</param>
/// <param name="eventId">The event id.</param>
/// <param name="eventType">The event type.</param>
/// <param name="relatedActiviyId">The related activity id.</param>
/// </summary>
protected virtual void ProcessLogEventInfo(LogLevel logLevel, string loggerName, [Localizable(false)] string message, object[] arguments, int?eventId, TraceEventType?eventType, Guid?relatedActiviyId)
{
loggerName = (loggerName ?? Name) ?? string.Empty;
StackTrace stackTrace = null;
int userFrameIndex = -1;
if (AutoLoggerName)
{
stackTrace = new StackTrace();
for (int i = 0; i < stackTrace.FrameCount; ++i)
{
var frame = stackTrace.GetFrame(i);
loggerName = Internal.StackTraceUsageUtils.LookupClassNameFromStackFrame(frame);
if (!string.IsNullOrEmpty(loggerName))
{
userFrameIndex = i;
break;
}
}
}
ILogger logger;
if (LogFactory != null)
{
logger = LogFactory.GetLogger(loggerName);
}
else
{
logger = LogManager.GetLogger(loggerName);
}
logLevel = _forceLogLevel ?? logLevel;
if (!logger.IsEnabled(logLevel))
{
return; // We are done
}
var ev = new LogEventInfo();
ev.LoggerName = loggerName;
ev.Level = logLevel;
if (eventType.HasValue)
{
ev.Properties.Add("EventType", eventType.Value);
}
if (relatedActiviyId.HasValue)
{
ev.Properties.Add("RelatedActivityID", relatedActiviyId.Value);
}
ev.Message = message;
ev.Parameters = arguments;
ev.Level = _forceLogLevel ?? logLevel;
if (eventId.HasValue)
{
ev.Properties.Add("EventID", eventId.Value);
}
if (stackTrace != null && userFrameIndex >= 0)
{
ev.SetStackTrace(stackTrace, userFrameIndex);
}
logger.Log(ev);
}
