public void GDCTest1()
{
GlobalDiagnosticsContext.Clear();
Assert.False(GlobalDiagnosticsContext.Contains("foo"));
Assert.Equal(string.Empty, GlobalDiagnosticsContext.Get("foo"));
Assert.False(GlobalDiagnosticsContext.Contains("foo2"));
Assert.Equal(string.Empty, GlobalDiagnosticsContext.Get("foo2"));
Assert.Equal(0, GlobalDiagnosticsContext.GetNames().Count);
GlobalDiagnosticsContext.Set("foo", "bar");
GlobalDiagnosticsContext.Set("foo2", "bar2");
Assert.True(GlobalDiagnosticsContext.Contains("foo"));
Assert.Equal("bar", GlobalDiagnosticsContext.Get("foo"));
Assert.Equal(2, GlobalDiagnosticsContext.GetNames().Count);
GlobalDiagnosticsContext.Remove("foo");
Assert.False(GlobalDiagnosticsContext.Contains("foo"));
Assert.Equal(string.Empty, GlobalDiagnosticsContext.Get("foo"));
Assert.True(GlobalDiagnosticsContext.Contains("foo2"));
Assert.Equal("bar2", GlobalDiagnosticsContext.Get("foo2"));
Assert.Equal(1, GlobalDiagnosticsContext.GetNames().Count);
Assert.Null(GlobalDiagnosticsContext.GetObject("foo3"));
Assert.Equal(string.Empty, GlobalDiagnosticsContext.Get("foo3", null));
GlobalDiagnosticsContext.Set("foo3", new { One = 1 });
Assert.NotNull(GlobalDiagnosticsContext.Get("foo3", null));
}
public void TargetWithContextAsyncTest()
{
CustomTargetWithContext target = new CustomTargetWithContext();
target.ContextProperties.Add(new TargetPropertyWithContext("threadid", "${threadid}"));
target.IncludeMdlc = true;
target.IncludeMdc = true;
target.IncludeGdc = true;
target.IncludeNdc = true;
target.IncludeNdlc = true;
target.IncludeCallSite = true;
AsyncTargetWrapper wrapper = new AsyncTargetWrapper();
wrapper.WrappedTarget = target;
wrapper.TimeToSleepBetweenBatches = 0;
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(wrapper, LogLevel.Debug);
Logger logger = LogManager.GetLogger("Example");
GlobalDiagnosticsContext.Clear();
GlobalDiagnosticsContext.Set("TestKey", "Hello Global World");
GlobalDiagnosticsContext.Set("GlobalKey", "Hello Global World");
MappedDiagnosticsContext.Clear();
MappedDiagnosticsContext.Set("TestKey", "Hello Thread World");
MappedDiagnosticsContext.Set("ThreadKey", "Hello Thread World");
MappedDiagnosticsLogicalContext.Clear();
MappedDiagnosticsLogicalContext.Set("TestKey", "Hello Async World");
MappedDiagnosticsLogicalContext.Set("AsyncKey", "Hello Async World");
logger.Debug("log message");
System.Threading.Thread.Sleep(1);
for (int i = 0; i < 1000; ++i)
{
if (target.LastMessage != null)
{
break;
}
System.Threading.Thread.Sleep(1);
}
Assert.NotEqual(0, target.LastMessage.Length);
Assert.NotNull(target.LastCombinedProperties);
Assert.NotEmpty(target.LastCombinedProperties);
Assert.Equal(7, target.LastCombinedProperties.Count);
Assert.Contains(new KeyValuePair <string, object>("GlobalKey", "Hello Global World"), target.LastCombinedProperties);
Assert.Contains(new KeyValuePair <string, object>("ThreadKey", "Hello Thread World"), target.LastCombinedProperties);
Assert.Contains(new KeyValuePair <string, object>("AsyncKey", "Hello Async World"), target.LastCombinedProperties);
Assert.Contains(new KeyValuePair <string, object>("TestKey", "Hello Async World"), target.LastCombinedProperties);
Assert.Contains(new KeyValuePair <string, object>("TestKey_1", "Hello Thread World"), target.LastCombinedProperties);
Assert.Contains(new KeyValuePair <string, object>("TestKey_2", "Hello Global World"), target.LastCombinedProperties);
Assert.Contains(new KeyValuePair <string, object>("threadid", System.Environment.CurrentManagedThreadId.ToString()), target.LastCombinedProperties);
}
public void IncludeGdcNoEmptyJsonProperties()
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog throwExceptions='true'>
<targets>
<target name='asyncDebug' type='AsyncWrapper' timeToSleepBetweenBatches='0'>
<target name='debug' type='Debug' >
<layout type=""JsonLayout"" IncludeGdc='true' ExcludeProperties='Excluded1,Excluded2' ExcludeEmptyProperties='true'>
</layout>
</target>
</target>
</targets>
<rules>
<logger name='*' minlevel='Debug' writeTo='asyncDebug' />
</rules>
</nlog>");
ILogger logger = LogManager.GetLogger("A");
var logEventInfo = CreateLogEventWithExcluded();
logEventInfo.Properties.Add("EmptyProp", "");
logEventInfo.Properties.Add("EmptyProp1", null);
logEventInfo.Properties.Add("EmptyProp2", new DummyContextLogger()
{
Value = null
});
logEventInfo.Properties.Add("EmptyProp3", new DummyContextLogger()
{
Value = ""
});
logEventInfo.Properties.Add("NoEmptyProp4", new DummyContextLogger()
{
Value = "hello"
});
GlobalDiagnosticsContext.Clear();
foreach (var prop in logEventInfo.Properties)
{
if (prop.Key.ToString() != "Excluded1" && prop.Key.ToString() != "Excluded2")
{
GlobalDiagnosticsContext.Set(prop.Key.ToString(), prop.Value);
}
}
logEventInfo.Properties.Clear();
logger.Debug(logEventInfo);
LogManager.Flush();
AssertDebugLastMessage("debug", ExpectedExcludeEmptyPropertiesWithExcludes);
}
public void GDCFormatTest()
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets><target name='debug' type='Debug' layout='${gdc:item=appid:format=@} ${message}' /></targets>
<rules>
<logger name='*' minlevel='Debug' writeTo='debug' />
</rules>
</nlog>");
GlobalDiagnosticsContext.Clear();
GlobalDiagnosticsContext.Set("appid", new { AppId = 123 });
LogManager.GetLogger("A").Debug("a");
AssertDebugLastMessage("debug", "{\"AppId\":123} a");
}
/// <summary>
/// Log the error or info for the method executions
/// </summary>
/// <param name="logInformation"></param>
/// <param name="memberName"></param>
/// <param name="sourceFilePath"></param>
/// <param name="sourceLineNumber"></param>
/// <returns></returns>
public void Log(LogInformation logInformation, [CallerMemberName] string memberName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
{
if (_appsettings.settings.IsLoggingEnabled)
{
SetNLogContext(logInformation, memberName, sourceFilePath, sourceLineNumber);
if (logInformation.Exception != null)
{
_logger.Error(logInformation.Exception, logInformation.Message);
}
else
{
_logger.Info(logInformation.Message);
}
//Now clear the context
GlobalDiagnosticsContext.Clear();
}
}
public void GDCTest1()
{
GlobalDiagnosticsContext.Clear();
Assert.IsFalse(GlobalDiagnosticsContext.Contains("foo"));
Assert.AreEqual(string.Empty, GlobalDiagnosticsContext.Get("foo"));
Assert.IsFalse(GlobalDiagnosticsContext.Contains("foo2"));
Assert.AreEqual(string.Empty, GlobalDiagnosticsContext.Get("foo2"));
GlobalDiagnosticsContext.Set("foo", "bar");
GlobalDiagnosticsContext.Set("foo2", "bar2");
Assert.IsTrue(GlobalDiagnosticsContext.Contains("foo"));
Assert.AreEqual("bar", GlobalDiagnosticsContext.Get("foo"));
GlobalDiagnosticsContext.Remove("foo");
Assert.IsFalse(GlobalDiagnosticsContext.Contains("foo"));
Assert.AreEqual(string.Empty, GlobalDiagnosticsContext.Get("foo"));
Assert.IsTrue(GlobalDiagnosticsContext.Contains("foo2"));
Assert.AreEqual("bar2", GlobalDiagnosticsContext.Get("foo2"));
}
public void KeyFoundRendersValue_Multiple_Cookies_Flat_Formatting_separators_layouts()
{
try
{
var expectedResult = "key>TEST" + Environment.NewLine + "Key1>TEST1";
GlobalDiagnosticsContext.Set("valueSeparator1", ">");
var renderer = CreateRenderer();
renderer.ValueSeparator = "${gdc:valueSeparator1}";
renderer.ItemSeparator = "${newline}";
string result = renderer.Render(new LogEventInfo());
Assert.Equal(expectedResult, result);
}
finally
{
//clean up
GlobalDiagnosticsContext.Clear();
}
}
/// <summary>
///
/// </summary>
protected override void Append(StringBuilder builder, LogEventInfo logEvent)
{
if (IsEnabled)
{
var controllerName = GlobalDiagnosticsContext.Get(LoggerExceptionHandler.CONTROLLER_CONTEXT_KEY);
var actionName = GlobalDiagnosticsContext.Get(LoggerExceptionHandler.ACTION_CONTEXT_KEY);
var actionArguments = GlobalDiagnosticsContext.Get(LoggerExceptionHandler.ACTION_ARGUMENTS_CONTEXT_KEY);
builder.AppendLine();
builder.AppendLine(String.Format(
"Action Arguments for {0}Controller.{1} =>",
controllerName == null ? "null" : controllerName,
actionName == null ? "null" : actionName));
builder.AppendLine(actionArguments == null ? "null" : actionArguments);
}
else
{
builder.AppendLine();
builder.AppendLine("Action argument logging disabled.");
}
GlobalDiagnosticsContext.Clear();
}
public void TargetWithContextAsyncTest()
{
CustomTargetWithContext target = new CustomTargetWithContext();
target.ContextProperties.Add(new TargetPropertyWithContext("threadid", "${threadid}"));
target.IncludeScopeProperties = true;
target.IncludeGdc = true;
target.IncludeScopeNestedStates = true;
target.IncludeCallSite = true;
AsyncTargetWrapper wrapper = new AsyncTargetWrapper();
wrapper.WrappedTarget = target;
wrapper.TimeToSleepBetweenBatches = 0;
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(wrapper, LogLevel.Debug);
Logger logger = LogManager.GetLogger("Example");
GlobalDiagnosticsContext.Clear();
ScopeContext.Clear();
GlobalDiagnosticsContext.Set("TestKey", "Hello Global World");
GlobalDiagnosticsContext.Set("GlobalKey", "Hello Global World");
ScopeContext.PushProperty("TestKey", "Hello Async World");
ScopeContext.PushProperty("AsyncKey", "Hello Async World");
logger.Debug("log message");
Assert.True(WaitForLastMessage(target));
Assert.NotEqual(0, target.LastMessage.Length);
Assert.NotNull(target.LastCombinedProperties);
Assert.NotEmpty(target.LastCombinedProperties);
Assert.Equal(5, target.LastCombinedProperties.Count);
Assert.Contains(new KeyValuePair <string, object>("GlobalKey", "Hello Global World"), target.LastCombinedProperties);
Assert.Contains(new KeyValuePair <string, object>("AsyncKey", "Hello Async World"), target.LastCombinedProperties);
Assert.Contains(new KeyValuePair <string, object>("TestKey", "Hello Async World"), target.LastCombinedProperties);
Assert.Contains(new KeyValuePair <string, object>("TestKey_1", "Hello Global World"), target.LastCombinedProperties);
Assert.Contains(new KeyValuePair <string, object>("threadid", System.Environment.CurrentManagedThreadId.ToString()), target.LastCombinedProperties);
}
