public void ScopePropertyFormatTests() { // Arrange ScopeContext.Clear(); var logFactory = new LogFactory(); logFactory.Setup().LoadConfigurationFromXml(@" <nlog> <targets><target name='debug' type='Debug' layout='${scopeproperty:item=myitem:format=@} ${message}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); var logger = logFactory.GetCurrentClassLogger(); var target = logFactory.Configuration.FindTargetByName <NLog.Targets.DebugTarget>("debug"); // Act using (logger.PushScopeProperty("myitem", new { RequestId = 123 })) { logger.Debug("a"); } // Assert Assert.Equal("{\"RequestId\":123} a", target.LastMessage); }
public void ScopeNestedTopTwoTest() { // Arrange ScopeContext.Clear(); var logFactory = new LogFactory(); logFactory.Setup().LoadConfigurationFromXml(@" <nlog> <targets><target name='debug' type='Debug' layout='${scopenested:topframes=2} ${message}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); var logger = logFactory.GetCurrentClassLogger(); var target = logFactory.Configuration.FindTargetByName <NLog.Targets.DebugTarget>("debug"); // Act using (logger.PushScopeState("ala")) { using (logger.PushScopeState("ma")) { using (logger.PushScopeState("kota")) { logger.Debug("c"); } } } // Assert Assert.Equal("ma kota c", target.LastMessage); }
public void LegacyMdlcSetShouldNotAffectStackValues3() { // Arrange ScopeContext.Clear(); var expectedValue = "Bob"; var expectedNestedState = "First Push"; object propertyValue1; object propertyValue2; object[] allNestedStates = null; var success1 = false; var success2 = false; // Act using (ScopeContext.PushNestedState(expectedNestedState)) { using (ScopeContext.PushProperty("Hello", "World")) { MappedDiagnosticsLogicalContext.Set("Hello", expectedValue); // Enter legacy mode (need to overwrite) success1 = ScopeContext.TryGetProperty("Hello", out propertyValue1); allNestedStates = ScopeContext.GetAllNestedStates(); } success2 = ScopeContext.TryGetProperty("Hello", out propertyValue2); } // Assert Assert.Single(allNestedStates); Assert.Equal(expectedNestedState, allNestedStates[0]); Assert.True(success1); Assert.Equal(expectedValue, propertyValue1); Assert.False(success2); Assert.Null(propertyValue2); }
public void ScopeNestedTwoPropertiesNewlineTest() { // Arrange ScopeContext.Clear(); var logFactory = new LogFactory(); logFactory.Setup().LoadConfigurationFromXml(@" <nlog> <targets><target name='debug' type='Debug' layout='${scopenested:format=@:separator=${newline}}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); var logger = logFactory.GetCurrentClassLogger(); var target = logFactory.Configuration.FindTargetByName <NLog.Targets.DebugTarget>("debug"); // Act using (logger.PushScopeState(new Dictionary <string, object>() { { "Hello", 42 }, { "Unlucky", 13 } })) { logger.Debug("c"); } // Assert Assert.Equal(string.Format("[{0}{{{0}\"Hello\": 42,{0}\"Unlucky\": 13{0}}}{0}]", System.Environment.NewLine), target.LastMessage); }
public void TargetWithContextConfigTest() { Target.Register("contexttarget", typeof(CustomTargetWithContext)); LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog throwExceptions='true'> <targets> <target name='debug' type='contexttarget' includeCallSite='true'> <contextproperty name='threadid' layout='${threadid}' hello='world' /> </target> </targets> <rules> <logger name='*' levels='Error' writeTo='debug' /> </rules> </nlog>"); ILogger logger = LogManager.GetLogger("A"); ScopeContext.Clear(); logger.Error("log message"); var target = LogManager.Configuration.FindTargetByName("debug") as CustomTargetWithContext; Assert.NotEqual(0, target.LastMessage.Length); var lastCombinedProperties = target.LastCombinedProperties; Assert.NotEmpty(lastCombinedProperties); Assert.Contains(new KeyValuePair <string, object>("threadid", System.Environment.CurrentManagedThreadId.ToString()), lastCombinedProperties); }
public void DoublePushNestedStateTest() { // Arrange ScopeContext.Clear(); var expectedNestedState1 = "First Push"; var expectedNestedState2 = System.Guid.NewGuid(); object topNestedState1 = null; object topNestedState2 = null; object[] allNestedStates = null; // Act using (ScopeContext.PushNestedState(expectedNestedState1)) { topNestedState1 = ScopeContext.PeekNestedState(); using (ScopeContext.PushNestedState(expectedNestedState2)) { topNestedState2 = ScopeContext.PeekNestedState(); allNestedStates = ScopeContext.GetAllNestedStates(); } } var failed = ScopeContext.PeekNestedState() != null; // Assert Assert.Equal(expectedNestedState1, topNestedState1); Assert.Equal(expectedNestedState2, topNestedState2); Assert.Equal(2, allNestedStates.Length); Assert.Equal(expectedNestedState2, allNestedStates[0]); Assert.Equal(expectedNestedState1, allNestedStates[1]); Assert.False(failed); }
public void LoggerPushPropertyTest() { // Arrange ScopeContext.Clear(); var expectedValue = "World"; Dictionary <string, object> allProperties = null; var success = false; object value; var logger = new LogFactory().GetCurrentClassLogger(); // Act using (logger.PushScopeProperty("HELLO", expectedValue)) { success = ScopeContext.TryGetProperty("hello", out value); allProperties = ScopeContext.GetAllProperties().ToDictionary(x => x.Key, x => x.Value); } var failed = ScopeContext.TryGetProperty("hello", out var _); // Assert Assert.True(success); Assert.Equal(expectedValue, value); Assert.Single(allProperties); Assert.Equal(expectedValue, allProperties["HELLO"]); Assert.False(failed); }
public void LoggerPushScopePropertiesCovarianceTest(bool convertDictionary) { // Arrange ScopeContext.Clear(); var expectedString = "World"; var expectedId = 42; IReadOnlyCollection <KeyValuePair <string, IConvertible> > expectedProperties = new[] { new KeyValuePair <string, IConvertible>("Hello", expectedString), new KeyValuePair <string, IConvertible>("RequestId", expectedId) }; if (convertDictionary) { expectedProperties = expectedProperties.ToDictionary(i => i.Key, i => i.Value); } Dictionary <string, object> allProperties = null; object stringValueLookup = null; var logger = new LogFactory().GetCurrentClassLogger(); // Act using (logger.PushScopeProperty("Hello", "People")) { using (logger.PushScopeProperties(expectedProperties)) { allProperties = ScopeContext.GetAllProperties().ToDictionary(x => x.Key, x => x.Value); } ScopeContext.TryGetProperty("Hello", out stringValueLookup); } // Assert Assert.Equal(2, allProperties.Count); Assert.Equal(expectedString, allProperties["Hello"]); Assert.Equal(expectedId, allProperties["RequestId"]); Assert.Equal(expectedProperties.Select(p => new KeyValuePair <string, object>(p.Key, p.Value)), allProperties); Assert.Equal("People", stringValueLookup); }
public void ScopeNestedSinglePropertyTest() { // Arrange ScopeContext.Clear(); var logFactory = new LogFactory(); logFactory.Setup().LoadConfigurationFromXml(@" <nlog> <targets><target name='debug' type='Debug' layout='${scopenested:format=@}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); var logger = logFactory.GetCurrentClassLogger(); var target = logFactory.Configuration.FindTargetByName <NLog.Targets.DebugTarget>("debug"); // Act using (logger.PushScopeState(new[] { new KeyValuePair <string, object>("Hello", "World") })) { logger.Debug("c"); } // Assert Assert.Equal("[ { \"Hello\": \"World\" } ]", target.LastMessage); }
public void LoggerPushScopePropertiesTest() { // Arrange ScopeContext.Clear(); var expectedString = "World"; var expectedGuid = System.Guid.NewGuid(); var expectedProperties = new[] { new KeyValuePair <string, object>("Hello", expectedString), new KeyValuePair <string, object>("RequestId", expectedGuid) }; IEnumerable <KeyValuePair <string, object> > allPropertiesState = null; Dictionary <string, object> allProperties = null; var logger = new LogFactory().GetCurrentClassLogger(); object stringValueLookup = null; // Act using (logger.PushScopeProperties(expectedProperties)) { allPropertiesState = ScopeContext.GetAllProperties(); allProperties = allPropertiesState.ToDictionary(x => x.Key, x => x.Value); } ScopeContext.TryGetProperty("Hello", out stringValueLookup); // Assert #if !NET35 && !NET40 && !NET45 Assert.Same(expectedProperties, allPropertiesState); #endif Assert.Equal(2, allProperties.Count); Assert.Equal(expectedString, allProperties["Hello"]); Assert.Equal(expectedGuid, allProperties["RequestId"]); Assert.Equal(expectedProperties.Select(p => new KeyValuePair <string, object>(p.Key, p.Value)), allProperties); Assert.Null(stringValueLookup); }
public void LoggerPushScopePropertiesOverwriteTest() { // Arrange ScopeContext.Clear(); var expectedString = "World"; var expectedGuid = System.Guid.NewGuid(); var expectedProperties = new[] { new KeyValuePair <string, object>("Hello", expectedString), new KeyValuePair <string, object>("RequestId", expectedGuid) }; Dictionary <string, object> allProperties = null; object stringValueLookup = null; var logger = new LogFactory().GetCurrentClassLogger(); // Act using (logger.PushScopeProperty("Hello", "People")) { using (logger.PushScopeProperties(expectedProperties)) { allProperties = ScopeContext.GetAllProperties().ToDictionary(x => x.Key, x => x.Value); } ScopeContext.TryGetProperty("Hello", out stringValueLookup); } // Assert Assert.Equal(2, allProperties.Count); Assert.Equal(expectedString, allProperties["Hello"]); Assert.Equal(expectedGuid, allProperties["RequestId"]); Assert.Equal(expectedProperties.Select(p => new KeyValuePair <string, object>(p.Key, p.Value)), allProperties); Assert.Equal("People", stringValueLookup); }
public void PushNestedStatePropertiesTest() { // Arrange ScopeContext.Clear(); var expectedString = "World"; var expectedGuid = System.Guid.NewGuid(); var expectedProperties = new[] { new KeyValuePair <string, object>("Hello", expectedString), new KeyValuePair <string, object>("RequestId", expectedGuid) }; var expectedNestedState = "First Push"; Dictionary <string, object> allProperties = null; object[] allNestedStates = null; object stringValueLookup = null; // Act using (ScopeContext.PushProperty("Hello", "People")) { using (ScopeContext.PushNestedStateProperties(expectedNestedState, expectedProperties)) { allNestedStates = ScopeContext.GetAllNestedStates(); allProperties = ScopeContext.GetAllProperties().ToDictionary(x => x.Key, x => x.Value); } ScopeContext.TryGetProperty("Hello", out stringValueLookup); } // Assert Assert.Equal(2, allProperties.Count); Assert.Equal(expectedString, allProperties["Hello"]); Assert.Equal(expectedGuid, allProperties["RequestId"]); Assert.Single(allNestedStates); Assert.Equal(expectedNestedState, allNestedStates[0]); Assert.Equal("People", stringValueLookup); }
public void LegacyMdlcSetShouldNotAffectStackValues2() { // Arrange ScopeContext.Clear(); var expectedValue = "World"; var expectedNestedState = "First Push"; object propertyValue; object[] allNestedStates = null; var success = false; // Act using (ScopeContext.PushNestedState(expectedNestedState)) { using (ScopeContext.PushProperty("Hello", expectedValue)) { MappedDiagnosticsLogicalContext.Set("Hello", expectedValue); // Skip legacy mode (ignore when same value) success = ScopeContext.TryGetProperty("Hello", out propertyValue); allNestedStates = ScopeContext.GetAllNestedStates(); } } // Assert Assert.Single(allNestedStates); Assert.Equal(expectedNestedState, allNestedStates[0]); Assert.True(success); Assert.Equal(expectedValue, propertyValue); }
public void TargetWithContextPropertyTypeTest() { Target.Register("contexttarget", typeof(CustomTargetWithContext)); LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog throwExceptions='true'> <targets> <default-wrapper type='AsyncWrapper' timeToSleepBetweenBatches='0' overflowAction='Block' /> <target name='debug' type='contexttarget' includeCallSite='true'> <contextproperty name='threadid' layout='${threadid}' propertyType='System.Int32' /> <contextproperty name='processid' layout='${processid}' propertyType='System.Int32' /> <contextproperty name='timestamp' layout='${date}' propertyType='System.DateTime' /> <contextproperty name='int-non-existing' layout='${event-properties:non-existing}' propertyType='System.Int32' includeEmptyValue='true' /> <contextproperty name='int-non-existing-empty' layout='${event-properties:non-existing}' propertyType='System.Int32' includeEmptyValue='false' /> <contextproperty name='object-non-existing' layout='${event-properties:non-existing}' propertyType='System.Object' includeEmptyValue='true' /> <contextproperty name='object-non-existing-empty' layout='${event-properties:non-existing}' propertyType='System.Object' includeEmptyValue='false' /> </target> </targets> <rules> <logger name='*' levels='Error' writeTo='debug' /> </rules> </nlog>"); ILogger logger = LogManager.GetLogger("A"); ScopeContext.Clear(); var logEvent = new LogEventInfo() { Message = "log message" }; logger.Error(logEvent); LogManager.Flush(); var target = LogManager.Configuration.AllTargets.OfType <CustomTargetWithContext>().FirstOrDefault(); Assert.NotEqual(0, target.LastMessage.Length); var lastCombinedProperties = target.LastCombinedProperties; Assert.NotEmpty(lastCombinedProperties); Assert.Contains(new KeyValuePair <string, object>("threadid", System.Environment.CurrentManagedThreadId), lastCombinedProperties); Assert.Contains(new KeyValuePair <string, object>("processid", System.Diagnostics.Process.GetCurrentProcess().Id), lastCombinedProperties); Assert.Contains(new KeyValuePair <string, object>("int-non-existing", 0), lastCombinedProperties); Assert.DoesNotContain("int-non-existing-empty", lastCombinedProperties.Keys); Assert.Contains(new KeyValuePair <string, object>("object-non-existing", ""), lastCombinedProperties); Assert.DoesNotContain("object-non-existing-empty", lastCombinedProperties.Keys); }
public void TargetWithContextJsonTest() { Target.Register("contexttarget", typeof(CustomTargetWithContext)); LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog throwExceptions='true'> <targets> <default-wrapper type='AsyncWrapper' timeToSleepBetweenBatches='0' overflowAction='Block' /> <target name='debug' type='contexttarget' includeCallSite='true'> <layout type='JsonLayout' includeScopeProperties='true'> <attribute name='level' layout='${level:upperCase=true}'/> <attribute name='message' layout='${message}' /> <attribute name='exception' layout='${exception}' /> <attribute name='threadid' layout='${threadid}' /> </layout> </target> </targets> <rules> <logger name='*' levels='Error' writeTo='debug' /> </rules> </nlog>"); ILogger logger = LogManager.GetLogger("A"); ScopeContext.Clear(); ScopeContext.PushProperty("TestKey", "Hello Thread World"); logger.Error("log message"); var target = LogManager.Configuration.AllTargets.OfType <CustomTargetWithContext>().FirstOrDefault(); 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.Contains(System.Environment.CurrentManagedThreadId.ToString(), target.LastMessage); var lastCombinedProperties = target.LastCombinedProperties; Assert.Empty(lastCombinedProperties); }
public void LegacyNdlcClearShouldNotAffectProperties1() { // Arrange ScopeContext.Clear(); var expectedValue = "World"; var success = false; object propertyValue; // Act using (ScopeContext.PushProperty("Hello", expectedValue)) { NestedDiagnosticsLogicalContext.Clear(); // Should not clear anything (skip legacy mode) success = ScopeContext.TryGetProperty("Hello", out propertyValue); } // Assert Assert.True(success); Assert.Equal(expectedValue, propertyValue); }
public void LegacyMdlcRemoveShouldNotAffectStackValues1() { // Arrange ScopeContext.Clear(); var expectedNestedState = "First Push"; object[] allNestedStates = null; // Act using (ScopeContext.PushNestedState(expectedNestedState)) { MappedDiagnosticsLogicalContext.Remove("Hello"); // Should not remove anything (skip legacy mode) allNestedStates = ScopeContext.GetAllNestedStates(); } // Assert Assert.Single(allNestedStates); Assert.Equal(expectedNestedState, allNestedStates[0]); }
public void PushPropertyNestedTest() { // Arrange ScopeContext.Clear(); var expectedString = "World"; var expectedGuid = System.Guid.NewGuid(); Dictionary <string, object> allProperties = null; object stringValueLookup1 = null; object stringValueLookup2 = null; bool stringValueLookup3 = false; object guidValueLookup1 = null; bool guidValueLookup2 = false; bool guidValueLookup3 = false; // Act using (ScopeContext.PushProperty("Hello", expectedString)) { using (ScopeContext.PushProperty("RequestId", expectedGuid)) { ScopeContext.TryGetProperty("Hello", out stringValueLookup1); ScopeContext.TryGetProperty("RequestId", out guidValueLookup1); allProperties = ScopeContext.GetAllProperties().ToDictionary(x => x.Key, x => x.Value); } ScopeContext.TryGetProperty("Hello", out stringValueLookup2); guidValueLookup2 = ScopeContext.TryGetProperty("RequestId", out var _); } guidValueLookup3 = ScopeContext.TryGetProperty("RequestId", out var _); stringValueLookup3 = ScopeContext.TryGetProperty("Hello", out var _); // Assert Assert.Equal(2, allProperties.Count); Assert.Equal(expectedString, allProperties["Hello"]); Assert.Equal(expectedGuid, allProperties["RequestId"]); Assert.Equal(expectedString, stringValueLookup1); Assert.Equal(expectedString, stringValueLookup2); Assert.Equal(expectedGuid, guidValueLookup1); Assert.False(guidValueLookup2); Assert.False(guidValueLookup3); Assert.False(guidValueLookup3); Assert.False(stringValueLookup3); }
public void LegacyMdlcRemoveShouldNotAffectStackValues2() { // Arrange ScopeContext.Clear(); var expectedValue1 = "World"; var expectedValue2 = System.Guid.NewGuid(); var expectedNestedState1 = "First Push"; var expectedNestedState2 = System.Guid.NewGuid(); object propertyValue1; object propertyValue2; object[] allNestedStates = null; var success1 = false; var success2 = false; // Act using (ScopeContext.PushNestedState(expectedNestedState1)) { using (ScopeContext.PushProperty("Hello", expectedValue1)) { using (ScopeContext.PushNestedState(expectedNestedState2)) { ScopeContext.PushProperty("RequestId", expectedValue2); MappedDiagnosticsLogicalContext.Remove("RequestId"); // Should not change stack (Legacy mode) allNestedStates = ScopeContext.GetAllNestedStates(); success1 = ScopeContext.TryGetProperty("Hello", out propertyValue1); success2 = ScopeContext.TryGetProperty("RequestId", out propertyValue2); } } } // Assert Assert.Equal(2, allNestedStates.Length); Assert.Equal(expectedNestedState2, allNestedStates[0]); Assert.Equal(expectedNestedState1, allNestedStates[1]); Assert.True(success1); Assert.False(success2); Assert.Equal(expectedValue1, propertyValue1); Assert.Null(propertyValue2); }
public void LegacyMdlcClearShouldNotAffectStackValues2() { // Arrange ScopeContext.Clear(); var expectedValue = "World"; var expectedNestedState = "First Push"; object[] allNestedStates = null; // Act using (ScopeContext.PushNestedState(expectedNestedState)) { ScopeContext.PushProperty("Hello", expectedValue); MappedDiagnosticsLogicalContext.Clear(); // Should not clear stack (Legacy mode) allNestedStates = ScopeContext.GetAllNestedStates(); } // Assert Assert.Single(allNestedStates); Assert.Equal(expectedNestedState, allNestedStates[0]); }
public void LayoutParserEscapeCodesForRegExTestV2() { ScopeContext.Clear(); var configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog throwExceptions='true'> <variable name=""searchExp"" value=""(?<!\\d[ -]*)(?\:(?<digits>\\d)[ -]*)\{8,16\}(?=(\\d[ -]*)\{3\}(\\d)(?![ -]\\d))"" /> <variable name=""message1"" value=""${replace:inner=${message}:searchFor=${searchExp}:replaceWith=\u003a\u003a:regex=true:ignorecase=true}"" /> <targets> <target name=""d1"" type=""Debug"" layout=""${message1}"" /> </targets> <rules> <logger name=""*"" minlevel=""Trace"" writeTo=""d1"" /> </rules> </nlog>"); var d1 = configuration.FindTargetByName("d1") as DebugTarget; Assert.NotNull(d1); var layout = d1.Layout as SimpleLayout; Assert.NotNull(layout); var c = layout.Renderers.Count; Assert.Equal(1, c); var l1 = layout.Renderers[0] as ReplaceLayoutRendererWrapper; Assert.NotNull(l1); Assert.True(l1.Regex); Assert.True(l1.IgnoreCase); Assert.Equal(@"::", l1.ReplaceWith); Assert.Equal(@"(?<!\d[ -]*)(?:(?<digits>\d)[ -]*){8,16}(?=(\d[ -]*){3}(\d)(?![ -]\d))", l1.SearchFor); }
public void XmlLayoutLog4j() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog throwExceptions='true'> <targets> <target name='debug' type='debug'> <layout type='xmllayout' elementName='log4j:event' propertiesElementName='log4j:data' propertiesElementKeyAttribute='name' propertiesElementValueAttribute='value' includeAllProperties='true' includeMdc='true' includeMdlc='true' > <attribute name='logger' layout='${logger}' includeEmptyValue='true' /> <attribute name='level' layout='${uppercase:${level}}' includeEmptyValue='true' /> <element name='log4j:message' value='${message}' /> <element name='log4j:throwable' value='${exception:format=tostring}' /> <element name='log4j:locationInfo'> <attribute name='class' layout='${callsite:methodName=false}' includeEmptyValue='true' /> </element> </layout> </target> </targets> <rules> <logger name='*' minlevel='debug' appendto='debug' /> </rules> </nlog>"); ScopeContext.Clear(); ScopeContext.PushProperty("foo1", "bar1"); ScopeContext.PushProperty("foo2", "bar2"); ScopeContext.PushProperty("foo3", "bar3"); var logger = LogManager.GetLogger("hello"); var logEventInfo = LogEventInfo.Create(LogLevel.Debug, "A", null, null, "some message"); logEventInfo.Properties["nlogPropertyKey"] = "<nlog\r\nPropertyValue>"; logger.Log(logEventInfo); var target = LogManager.Configuration.FindTargetByName <NLog.Targets.DebugTarget>("debug"); Assert.Equal(@"<log4j:event logger=""A"" level=""DEBUG""><log4j:message>some message</log4j:message><log4j:locationInfo class=""NLog.UnitTests.Layouts.XmlLayoutTests""/><log4j:data name=""foo1"" value=""bar1""/><log4j:data name=""foo2"" value=""bar2""/><log4j:data name=""foo3"" value=""bar3""/><log4j:data name=""nlogPropertyKey"" value=""<nlog PropertyValue>""/></log4j:event>", target.LastMessage); }
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); }
public void LegacyNdlcPopShouldNotAffectProperties3() { // Arrange ScopeContext.Clear(); var expectedValue1 = "World"; var expectedValue2 = System.Guid.NewGuid(); var expectedNestedState1 = "First Push"; var expectedNestedState2 = System.Guid.NewGuid(); var success1 = false; var success2 = false; object propertyValue1; object propertyValue2; object nestedState1; object nestedState2; // Act using (ScopeContext.PushProperty("Hello", expectedValue1)) { ScopeContext.PushNestedState(expectedNestedState1); ScopeContext.PushNestedState(expectedNestedState2); using (ScopeContext.PushProperty("RequestId", expectedValue2)) { nestedState2 = NestedDiagnosticsLogicalContext.PopObject(); // Evil pop where it should leave properties alone (Legacy mode) nestedState1 = NestedDiagnosticsLogicalContext.PopObject(); // Evil pop where it should leave properties alone (Legacy mode) success1 = ScopeContext.TryGetProperty("Hello", out propertyValue1); success2 = ScopeContext.TryGetProperty("RequestId", out propertyValue2); } } // Assert Assert.True(success1); Assert.True(success2); Assert.Equal(expectedValue1, propertyValue1); Assert.Equal(expectedValue2, propertyValue2); Assert.Equal(expectedNestedState1, nestedState1); Assert.Equal(expectedNestedState2, nestedState2); }
public void PushNestedStateTest() { // Arrange ScopeContext.Clear(); var expectedNestedState = "First Push"; object topNestedState = null; object[] allNestedStates = null; // Act using (ScopeContext.PushNestedState(expectedNestedState)) { topNestedState = ScopeContext.PeekNestedState(); allNestedStates = ScopeContext.GetAllNestedStates(); } var failed = ScopeContext.PeekNestedState() != null; // Assert Assert.Equal(expectedNestedState, topNestedState); Assert.Single(allNestedStates); Assert.Equal(expectedNestedState, allNestedStates[0]); Assert.False(failed); }
public void LegacyNdlcPopShouldNotAffectProperties2() { // Arrange ScopeContext.Clear(); var expectedValue = "World"; var expectedNestedState = "First Push"; var success = false; object propertyValue; object nestedState; // Act using (ScopeContext.PushProperty("Hello", expectedValue)) { ScopeContext.PushNestedState(expectedNestedState); nestedState = NestedDiagnosticsLogicalContext.PopObject(); // Should only pop active scope (skip legacy mode) success = ScopeContext.TryGetProperty("Hello", out propertyValue); } // Assert Assert.True(success); Assert.Equal(expectedValue, propertyValue); Assert.Equal(expectedNestedState, nestedState); }
public void ClearScopeContextTest() { // Arrange ScopeContext.Clear(); var expectedNestedState = "First Push"; var expectedString = "World"; var expectedGuid = System.Guid.NewGuid(); object[] allNestedStates1 = null; object[] allNestedStates2 = null; object stringValueLookup1 = null; object stringValueLookup2 = null; // Act using (ScopeContext.PushProperty("Hello", expectedString)) { using (ScopeContext.PushProperty("RequestId", expectedGuid)) { using (ScopeContext.PushNestedState(expectedNestedState)) { ScopeContext.Clear(); allNestedStates1 = ScopeContext.GetAllNestedStates(); ScopeContext.TryGetProperty("Hello", out stringValueLookup1); } } // Original scope was restored on dispose, verify expected behavior allNestedStates2 = ScopeContext.GetAllNestedStates(); ScopeContext.TryGetProperty("Hello", out stringValueLookup2); } // Assert Assert.Null(stringValueLookup1); Assert.Equal(expectedString, stringValueLookup2); Assert.Empty(allNestedStates1); Assert.Empty(allNestedStates2); }
public void LoggerPushNestedStatePrimitiveTest() { // Arrange ScopeContext.Clear(); var expectedNestedState = 42; object topNestedState = null; object[] allNestedStates = null; var logger = new LogFactory().GetCurrentClassLogger(); // Act using (logger.PushScopeState(expectedNestedState)) { topNestedState = ScopeContext.PeekNestedState(); allNestedStates = ScopeContext.GetAllNestedStates(); } var failed = ScopeContext.PeekNestedState() != null; // Assert Assert.Equal(expectedNestedState, topNestedState); Assert.Single(allNestedStates); Assert.Equal(expectedNestedState, allNestedStates[0]); Assert.False(failed); }
public void PushPropertyCaseInsensitiveTest() { // Arrange ScopeContext.Clear(); var expectedValue = "World"; Dictionary <string, object> allProperties = null; var success = false; object value; // Act using (ScopeContext.PushProperty("HELLO", expectedValue)) { success = ScopeContext.TryGetProperty("hello", out value); allProperties = ScopeContext.GetAllProperties().ToDictionary(x => x.Key, x => x.Value); } var failed = ScopeContext.TryGetProperty("hello", out var _); // Assert Assert.True(success); Assert.Equal(expectedValue, value); Assert.Single(allProperties); Assert.Equal(expectedValue, allProperties["HELLO"]); Assert.False(failed); }
public void ScopeNestedTimingTest() { // Arrange ScopeContext.Clear(); var logFactory = new LogFactory(); logFactory.Setup().LoadConfigurationFromXml(@" <nlog> <targets><target name='debug' type='Debug' layout='${ndlc}|${scopetiming:CurrentScope=false:StartTime=true:Format=yyyy-MM-dd HH\:mm\:ss}|${scopetiming:CurrentScope=false:StartTime=false:Format=fff}|${scopetiming:CurrentScope=true:StartTime=true:Format=HH\:mm\:ss.fff}|${scopetiming:CurrentScope=true:StartTime=false:Format=fffffff}|${message}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); var logger = logFactory.GetCurrentClassLogger(); var target = logFactory.Configuration.FindTargetByName <NLog.Targets.DebugTarget>("debug"); logger.Debug("0"); string messageNoScope = target.LastMessage; string messageFirstScope; string messageFirstScopeSleep; string messageFirstScopeExit; string messageSecondScope; string messageSecondScopeSleep; Assert.Equal("|||||0", messageNoScope); using (logger.PushScopeState("ala")) { logger.Debug("a"); messageFirstScope = target.LastMessage; System.Threading.Thread.Sleep(10); logger.Debug("b"); messageFirstScopeSleep = target.LastMessage; using (logger.PushScopeState("ma")) { logger.Debug("a"); messageSecondScope = target.LastMessage; System.Threading.Thread.Sleep(10); logger.Debug("b"); messageSecondScopeSleep = target.LastMessage; } logger.Debug("c"); messageFirstScopeExit = target.LastMessage; } // Assert var measurements = messageFirstScope.Split(new[] { '|' }, System.StringSplitOptions.RemoveEmptyEntries); Assert.Equal(6, measurements.Length); Assert.Equal("ala", measurements[0]); Assert.InRange(int.Parse(measurements[2]), 0, 999); Assert.InRange(int.Parse(measurements[4]), 0, 9999999); Assert.Equal("a", measurements[measurements.Length - 1]); measurements = messageFirstScopeSleep.Split(new[] { '|' }, System.StringSplitOptions.RemoveEmptyEntries); Assert.Equal("ala", measurements[0]); Assert.InRange(int.Parse(measurements[2]), 10, 999); Assert.InRange(int.Parse(measurements[4]), 100000, 9999999); Assert.Equal("b", measurements[measurements.Length - 1]); measurements = messageSecondScope.Split(new[] { '|' }, System.StringSplitOptions.RemoveEmptyEntries); Assert.Equal(6, measurements.Length); Assert.Equal("ala ma", measurements[0]); Assert.InRange(int.Parse(measurements[2]), 10, 999); Assert.InRange(int.Parse(measurements[4]), 0, 9999999); Assert.Equal("a", measurements[measurements.Length - 1]); measurements = messageSecondScopeSleep.Split(new[] { '|' }, System.StringSplitOptions.RemoveEmptyEntries); Assert.Equal(6, measurements.Length); Assert.Equal("ala ma", measurements[0]); Assert.InRange(int.Parse(measurements[2]), 20, 999); Assert.InRange(int.Parse(measurements[4]), 100000, 9999999); Assert.Equal("b", measurements[measurements.Length - 1]); measurements = messageFirstScopeExit.Split(new[] { '|' }, System.StringSplitOptions.RemoveEmptyEntries); Assert.Equal("ala", measurements[0]); Assert.InRange(int.Parse(measurements[2]), 20, 999); Assert.InRange(int.Parse(measurements[4]), 200000, 9999999); Assert.Equal("c", measurements[measurements.Length - 1]); }