public void TimeTest() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets><target name='debug' type='Debug' layout='${time}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); LogManager.GetLogger("d").Debug("zzz"); string date = GetDebugLastMessage("debug"); Assert.Equal(13, date.Length); Assert.Equal(':', date[2]); Assert.Equal(':', date[5]); Assert.Equal('.', date[8]); }
public void ShowFileNameOnlyAsyncTest() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets><target name='debug' type='Debug' layout='${callsite-filename:includeSourcePath=False}|${message}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); AsyncMethod().Wait(); var lastMessage = GetDebugLastMessage("debug"); var lastMessageArray = lastMessage.Split('|'); Assert.Equal("CallSiteFileNameLayoutTests.cs", lastMessageArray[0]); Assert.Equal("msg", lastMessageArray[1]); }
public void TraceWriteNonDefaultLevelTest() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets><target name='debug' type='Debug' layout='${logger} ${level} ${message}' /></targets> <rules> <logger name='*' minlevel='Trace' writeTo='debug' /> </rules> </nlog>"); Trace.Listeners.Clear(); Trace.Listeners.Add(new NLogTraceListener { Name = "Logger1", DefaultLogLevel = LogLevel.Trace }); Trace.Write("Hello"); AssertDebugLastMessage("debug", "Logger1 Trace Hello"); }
public void AutoLoggerNameTest() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets><target name='debug' type='Debug' layout='${logger} ${level} ${message}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); Trace.Listeners.Clear(); Trace.Listeners.Add(new NLogTraceListener { Name = "Logger1", AutoLoggerName = true }); Trace.Write("Hello"); AssertDebugLastMessage("debug", GetType().FullName + " Debug Hello"); }
public void Flush_DoNotThrowExceptionsAndTimeout_DoesNotThrow() { using (new NoThrowNLogExceptions()) { LogManager.ThrowExceptions = true; LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog throwExceptions='false'> <targets><target type='MethodCall' name='test' methodName='Throws' className='NLog.UnitTests.LogFactoryTests, NLog.UnitTests.netfx40' /></targets> <rules> <logger name='*' minlevel='Debug' writeto='test'></logger> </rules> </nlog>"); ILogger logger = LogManager.GetCurrentClassLogger(); logger.Factory.Flush(_ => { }, TimeSpan.FromMilliseconds(1)); } }
public void RenderStackTrace_raw() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets><target name='debug' type='Debug' layout='${message} ${stacktrace:format=Raw}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); RenderMe("I am:"); AssertDebugLastMessageContains("debug", "RenderStackTrace_raw at offset "); AssertDebugLastMessageContains("debug", "RenderMe at offset "); #if !MONO AssertDebugLastMessageContains("debug", "StackTraceRendererTests.cs"); #endif }
public void HostNameTest() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets><target name='debug' type='Debug' layout='${hostname} ${message}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); // Get the actual hostname that the code would use string h = Environment.GetEnvironmentVariable("HOSTNAME") ?? System.Net.Dns.GetHostName() ?? Environment.GetEnvironmentVariable("COMPUTERNAME"); LogManager.GetLogger("A").Debug("a log message"); AssertDebugLastMessage("debug", h + " a log message"); }
public void Bug3990StackOverflowWhenUsingNLogViewerTarget() { // this would fail because of stack overflow in the // constructor of NLogViewerTarget var config = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets> <target name='viewer' type='NLogViewer' address='udp://127.0.0.1:9999' /> </targets> <rules> <logger name='*' minlevel='Debug' writeTo='viewer' /> </rules> </nlog>"); var target = config.LoggingRules[0].Targets[0] as NLogViewerTarget; Assert.NotNull(target); }
public void ThreadNameTest() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets><target name='debug' type='Debug' layout='${threadname} ${message}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); if (System.Threading.Thread.CurrentThread.Name == null) { System.Threading.Thread.CurrentThread.Name = "mythreadname"; } LogManager.GetLogger("A").Debug("a"); AssertDebugLastMessage("debug", System.Threading.Thread.CurrentThread.Name + " a"); }
public void UnusedTargetsShouldBeLoggedToInternalLogger_PermitWrapped() { string tempFileName = Path.GetTempFileName(); try { XmlLoggingConfiguration.CreateFromXmlString("<nlog internalLogFile='" + tempFileName + @"' internalLogLevel='Warn'> <extensions> <add assembly='NLog.UnitTests'/> </extensions> <targets> <target name='d1' type='Debug' /> <target name='d2' type='MockWrapper'> <target name='d3' type='Debug' /> </target> <target name='d4' type='Debug' /> <target name='d5' type='Debug' /> </targets> <rules> <logger name='*' level='Debug' writeTo='d1' /> <logger name='*' level='Debug' writeTo='d1,d2,d4' /> </rules> </nlog>"); AssertFileNotContains(tempFileName, "Unused target detected. Add a rule for this target to the configuration. TargetName: d2", Encoding.UTF8); AssertFileNotContains(tempFileName, "Unused target detected. Add a rule for this target to the configuration. TargetName: d3", Encoding.UTF8); AssertFileNotContains(tempFileName, "Unused target detected. Add a rule for this target to the configuration. TargetName: d4", Encoding.UTF8); AssertFileContains(tempFileName, "Unused target detected. Add a rule for this target to the configuration. TargetName: d5", Encoding.UTF8); } finally { NLog.Common.InternalLogger.Reset(); if (File.Exists(tempFileName)) { File.Delete(tempFileName); } } }
public void NoHeadersTest() { string tempFile = string.Empty; try { tempFile = Path.GetTempFileName(); LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets> <target name='f' type='File' fileName='" + tempFile + @"'> <layout type='CSVLayout' withHeader='false'> <delimiter>Comma</delimiter> <column name='level' layout='${level}' /> <column name='message' layout='${message}' /> <column name='counter' layout='${counter}' /> </layout> </target> </targets> <rules> <logger name='*' minlevel='Debug' writeTo='f' /> </rules> </nlog>"); ILogger logger = LogManager.GetLogger("A"); logger.Debug("msg"); logger.Info("msg2"); logger.Warn("Message with, a comma"); using (StreamReader sr = File.OpenText(tempFile)) { Assert.Equal("Debug,msg,1", sr.ReadLine()); Assert.Equal("Info,msg2,2", sr.ReadLine()); Assert.Equal("Warn,\"Message with, a comma\",3", sr.ReadLine()); } } finally { if (File.Exists(tempFile)) { File.Delete(tempFile); } } }
public void ExtensionWithPrefixTest() { var configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog throwExceptions='true'> <extensions> <add prefix='myprefix' assemblyFile='" + GetExtensionAssemblyFullPath() + @"' /> </extensions> <targets> <target name='t' type='myprefix.MyTarget' /> <target name='d1' type='Debug' layout='${myprefix.foo}' /> <target name='d2' type='Debug'> <layout type='myprefix.FooLayout' x='1'> </layout> </target> </targets> <rules> <logger name='*' writeTo='t'> <filters> <myprefix.whenFoo x='44' action='Ignore' /> </filters> </logger> </rules> </nlog>"); Target myTarget = configuration.FindTargetByName("t"); Assert.Equal("MyExtensionNamespace.MyTarget", myTarget.GetType().FullName); var d1Target = (DebugTarget)configuration.FindTargetByName("d1"); var layout = d1Target.Layout as SimpleLayout; Assert.NotNull(layout); Assert.Single(layout.Renderers); Assert.Equal("MyExtensionNamespace.FooLayoutRenderer", layout.Renderers[0].GetType().FullName); var d2Target = (DebugTarget)configuration.FindTargetByName("d2"); Assert.Equal("MyExtensionNamespace.FooLayout", d2Target.Layout.GetType().FullName); Assert.Equal(1, configuration.LoggingRules[0].Filters.Count); Assert.Equal("MyExtensionNamespace.WhenFooFilter", configuration.LoggingRules[0].Filters[0].GetType().FullName); }
internal static void ConsoleRaceCondtionIgnoreInnerTest(string configXml) { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(configXml); // Console.Out.Writeline / Console.Error.Writeline could throw 'IndexOutOfRangeException', which is a bug. // See https://stackoverflow.com/questions/33915790/console-out-and-console-error-race-condition-error-in-a-windows-service-written // and https://connect.microsoft.com/VisualStudio/feedback/details/2057284/console-out-probable-i-o-race-condition-issue-in-multi-threaded-windows-service // // Full error: // Error during session close: System.IndexOutOfRangeException: Probable I/ O race condition detected while copying memory. // The I/ O package is not thread safe by default.In multithreaded applications, // a stream must be accessed in a thread-safe way, such as a thread - safe wrapper returned by TextReader's or // TextWriter's Synchronized methods.This also applies to classes like StreamWriter and StreamReader. var oldOut = Console.Out; var oldError = Console.Error; try { Console.SetOut(StreamWriter.Null); Console.SetError(StreamWriter.Null); LogManager.ThrowExceptions = true; var logger = LogManager.GetCurrentClassLogger(); Parallel.For(0, 10, new ParallelOptions() { MaxDegreeOfParallelism = 10 }, (_) => { for (int i = 0; i < 100; i++) { logger.Trace("test message to the out and error stream"); } }); } finally { Console.SetOut(oldOut); Console.SetError(oldError); } }
[InlineData(16384)] // Acceptable value public void ConfigurationMaxKilobytes_ShouldBeAsSpecified_WhenMaxKilobytesIsValid(long?maxKilobytes) { var expectedMaxKilobytes = maxKilobytes; string configrationText = $@" <nlog ThrowExceptions='true'> <targets> <target type='EventLog' name='eventLog1' layout='${{message}}' maxKilobytes='{maxKilobytes}' /> </targets> <rules> <logger name='*' writeTo='eventLog1' /> </rules> </nlog>"; LoggingConfiguration configuration = XmlLoggingConfiguration.CreateFromXmlString(configrationText); var eventLog1 = configuration.FindTargetByName <EventLogTarget>("eventLog1"); Assert.Equal(expectedMaxKilobytes, eventLog1.MaxKilobytes); }
public void SingleLevelTest() { LoggingConfiguration c = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets> <target name='d1' type='Debug' /> </targets> <rules> <logger name='*' level='Warn' writeTo='d1' /> </rules> </nlog>"); Assert.Equal(1, c.LoggingRules.Count); var rule = c.LoggingRules[0]; Assert.Single(rule.Levels); Assert.Contains(LogLevel.Warn, rule.Levels); }
static LoggingConfiguration InitNLogConfig() { // https://github.com/NLog/NLog/wiki/Getting-started-with-ASP.NET-Core-5 var xmlConfigStr = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + "<nlog xmlns=\"http://www.nlog-project.org/schemas/NLog.xsd\"" + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"" + " autoReload=\"true\"" + " internalLogLevel=\"info\"" + " internalLogFile=\"logs" + Path.DirectorySeparatorChar + "internal-nlog.txt\">" + // enable asp.net core layout renderers " <extensions>" + " <add assembly=\"NLog.Web.AspNetCore\"/>" + " </extensions>" + // the targets to write to " <targets>" + // write logs to file " <target xsi:type=\"File\" name=\"allfile\" fileName=\"logs" + Path.DirectorySeparatorChar + "nlog-all-${shortdate}.log\"" + " layout=\"${longdate}|${event-properties:item=EventId_Id}|${uppercase:${level}}|${logger}|${message} ${exception:format=tostring}\"/>" + // another file log, only own logs. Uses some ASP.NET core renderers " <target xsi:type=\"File\" name=\"ownFile-web\" fileName=\"logs" + Path.DirectorySeparatorChar + "nlog-own-${shortdate}.log\"" + " layout=\"${longdate}|${event-properties:item=EventId_Id}|${uppercase:${level}}|${logger}|${message} ${exception:format=tostring}|url: ${aspnet-request-url}|action: ${aspnet-mvc-action}\"/>" + // Console Target for hosting lifetime messages to improve Docker / Visual Studio startup detection " <target xsi:type=\"Console\" name=\"lifetimeConsole\" layout=\"${level:truncate=4:tolower=true}\\: ${logger}[0]${newline} ${message}${exception:format=tostring}\" />" + " </targets>" + // rules to map from logger name to target " <rules>" + // All logs, including from Microsoft " <logger name=\"*\" minlevel=\"Trace\" writeTo=\"allfile\"/>" + // Output hosting lifetime messages to console target for faster startup detection " <logger name=\"Microsoft.Hosting.Lifetime\" minlevel=\"Info\" writeTo=\"lifetimeConsole, ownFile-web\" final=\"true\" />" + // Skip non-critical Microsoft logs and so log only own logs " <logger name=\"Microsoft.*\" maxLevel=\"Info\" final=\"true\"/>" + " <logger name=\"System.Net.Http.*\" maxlevel=\"Info\" final=\"true\" />" + // BlackHole without writeTo " <logger name=\"*\" minlevel=\"Trace\" writeTo=\"ownFile-web\"/>" + " </rules>" + "</nlog>"; var xmlConfig = XmlLoggingConfiguration.CreateFromXmlString(xmlConfigStr); return(xmlConfig); }
public void ArrayElementParameterTest() { LoggingConfiguration c = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets> <target type='MethodCall' name='mct'> <parameter> <name>p1</name> <layout>${message}</layout> </parameter> <parameter> <name>p2</name> <layout type='CsvLayout'> <column name='x' layout='${message}' /> <column name='y' layout='${level}' /> </layout> </parameter> <parameter> <name>p3</name> <layout>${logger}</layout> </parameter> </target> </targets> </nlog>"); var t = c.FindTargetByName("mct") as MethodCallTarget; Assert.NotNull(t); Assert.Equal(3, t.Parameters.Count); Assert.Equal("p1", t.Parameters[0].Name); Assert.Equal("'${message}'", t.Parameters[0].Layout.ToString()); Assert.Equal("p2", t.Parameters[1].Name); CsvLayout csvLayout = t.Parameters[1].Layout as CsvLayout; Assert.NotNull(csvLayout); Assert.Equal(2, csvLayout.Columns.Count); Assert.Equal("x", csvLayout.Columns[0].Name); Assert.Equal("y", csvLayout.Columns[1].Name); Assert.Equal("p3", t.Parameters[2].Name); Assert.Equal("'${logger}'", t.Parameters[2].Layout.ToString()); }
void FuncLayoutRendererRegisterTest1WithXML() { LayoutRenderer.Register("the-answer", (info) => 42); LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog throwExceptions='true'> <targets> <target name='debug' type='Debug' layout= 'TheAnswer=${the-answer:Format=D3}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); var logger = LogManager.GetCurrentClassLogger(); logger.Debug("test1"); AssertDebugLastMessage("debug", "TheAnswer=042"); }
public void CompoundTest() { LoggingConfiguration c = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets> <compound-target name='rr' type='RoundRobinGroup'> <target name='d1' type='Debug' layout='${message}1' /> <target name='d2' type='Debug' layout='${message}2' /> <target name='d3' type='Debug' layout='${message}3' /> <target name='d4' type='Debug' layout='${message}4' /> </compound-target> </targets> </nlog>"); Assert.NotNull(c.FindTargetByName("rr")); Assert.NotNull(c.FindTargetByName("d1")); Assert.NotNull(c.FindTargetByName("d2")); Assert.NotNull(c.FindTargetByName("d3")); Assert.NotNull(c.FindTargetByName("d4")); Assert.IsType <RoundRobinGroupTarget>(c.FindTargetByName("rr")); Assert.IsType <DebugTarget>(c.FindTargetByName("d1")); Assert.IsType <DebugTarget>(c.FindTargetByName("d2")); Assert.IsType <DebugTarget>(c.FindTargetByName("d3")); Assert.IsType <DebugTarget>(c.FindTargetByName("d4")); RoundRobinGroupTarget rr = c.FindTargetByName("rr") as RoundRobinGroupTarget; DebugTarget d1 = c.FindTargetByName("d1") as DebugTarget; DebugTarget d2 = c.FindTargetByName("d2") as DebugTarget; DebugTarget d3 = c.FindTargetByName("d3") as DebugTarget; DebugTarget d4 = c.FindTargetByName("d4") as DebugTarget; Assert.Equal(4, rr.Targets.Count); Assert.Same(d1, rr.Targets[0]); Assert.Same(d2, rr.Targets[1]); Assert.Same(d3, rr.Targets[2]); Assert.Same(d4, rr.Targets[3]); Assert.Equal("${message}1", ((SimpleLayout)d1.Layout).Text); Assert.Equal("${message}2", ((SimpleLayout)d2.Layout).Text); Assert.Equal("${message}3", ((SimpleLayout)d3.Layout).Text); Assert.Equal("${message}4", ((SimpleLayout)d4.Layout).Text); }
public void ExceptionWithStackTraceTest() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets> <target name='debug1' type='Debug' layout='${exception}' /> <target name='debug2' type='Debug' layout='${exception:format=stacktrace}' /> <target name='debug3' type='Debug' layout='${exception:format=type}' /> <target name='debug4' type='Debug' layout='${exception:format=shorttype}' /> <target name='debug5' type='Debug' layout='${exception:format=tostring}' /> <target name='debug6' type='Debug' layout='${exception:format=message}' /> <target name='debug7' type='Debug' layout='${exception:format=method}' /> <target name='debug8' type='Debug' layout='${exception:format=message,shorttype:separator=*}' /> <target name='debug9' type='Debug' layout='${exception:format=data}' /> </targets> <rules> <logger minlevel='Info' writeTo='debug1,debug2,debug3,debug4,debug5,debug6,debug7,debug8,debug9' /> </rules> </nlog>"); const string exceptionMessage = "Test exception"; const string exceptionDataKey = "testkey"; const string exceptionDataValue = "testvalue"; Exception ex = GetExceptionWithStackTrace(exceptionMessage); ex.Data.Add(exceptionDataKey, exceptionDataValue); logger.Error(ex, "msg"); AssertDebugLastMessage("debug1", exceptionMessage); AssertDebugLastMessage("debug2", ex.StackTrace); AssertDebugLastMessage("debug3", typeof(CustomArgumentException).FullName); AssertDebugLastMessage("debug4", typeof(CustomArgumentException).Name); AssertDebugLastMessage("debug5", ex.ToString()); AssertDebugLastMessage("debug6", exceptionMessage); AssertDebugLastMessage("debug9", string.Format(ExceptionDataFormat, exceptionDataKey, exceptionDataValue)); // each version of the framework produces slightly different information for MethodInfo, so we just // make sure it's not empty var debug7Target = (DebugTarget)LogManager.Configuration.FindTargetByName("debug7"); Assert.False(string.IsNullOrEmpty(debug7Target.LastMessage)); AssertDebugLastMessage("debug8", exceptionMessage + "*" + typeof(CustomArgumentException).Name); }
public void PerformanceCounterLayoutRendererTest() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets><target name='debug' type='Debug' layout='${performancecounter:category=Process:counter=Working Set:format=F0:MachineName=}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); ILogger logger = LogManager.GetLogger("A"); logger.Debug("a"); Assert.NotEqual(0, long.Parse(GetDebugLastMessage("debug"))); logger.Debug("b"); logger.Debug("c"); logger.Debug("d"); Assert.NotEqual(0, long.Parse(GetDebugLastMessage("debug"))); }
[InlineData("1:0:0:0", 86400)] //1 day public void SetTimeSpanFromXmlTest(string interval, int seconds) { var config = XmlLoggingConfiguration.CreateFromXmlString($@" <nlog throwExceptions='true'> <targets> <wrapper-target name='limiting' type='LimitingWrapper' messagelimit='5' interval='{interval}'> <target name='debug' type='Debug' layout='${{message}}' /> </wrapper-target> </targets> <rules> <logger name='*' level='Debug' writeTo='limiting' /> </rules> </nlog>"); var target = config.FindTargetByName <LimitingTargetWrapper>("limiting"); Assert.NotNull(target); Assert.Equal(TimeSpan.FromSeconds(seconds), target.Interval); }
public void LineNumberOnlyAsyncTest() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets><target name='debug' type='Debug' layout='${callsite-linenumber}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); ILogger logger = LogManager.GetLogger("A"); Func <string> getLastMessage = () => GetDebugLastMessage("debug"); logger.Debug("msg"); var lastMessage = getLastMessage(); Assert.NotEqual(0, int.Parse(lastMessage)); WriteMessages(logger, getLastMessage).Wait(); }
public void WebserviceTest_restapi_xml() { var configuration = XmlLoggingConfiguration.CreateFromXmlString($@" <nlog throwExceptions='true'> <targets> <target type='WebService' name='ws' url='{getWsAddress(1)}{"api/logdoc/xml"}' protocol='XmlPost' XmlRoot='ComplexType' encoding='UTF-8' > <parameter name='param1' ParameterType='System.String' layout='${{message}}'/> <parameter name='param2' ParameterType='System.String' layout='${{level}}'/> <parameter name='param3' ParameterType='System.Boolean' layout='True'/> <parameter name='param4' ParameterType='System.DateTime' layout='${{date:universalTime=true:format=o}}'/> </target> </targets> <rules> <logger name='*' writeTo='ws'> </logger> </rules> </nlog>"); LogManager.Configuration = configuration; var logger = LogManager.GetCurrentClassLogger(); var txt = "message 1 with a XML POST<hello><again\\>\""; // Lets tease the Xml-Serializer, and see it can handle xml-tags var count = 101; var context = new LogDocController.TestContext(1, count, true, null, txt, "info", true, DateTime.UtcNow); StartOwinDocTest(context, () => { for (int i = 0; i < count; i++) { logger.Info(txt + "\b"); // Lets tease the Xml-Serializer, and see it can remove invalid chars } }); Assert.Equal <int>(0, context.CountdownEvent.CurrentCount); }
public void Xml_configuration_with_innerLayouts_returns_defined_variables() { var configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog throwExceptions='true'> <variable name='myJson' > <layout type='JsonLayout'> <attribute name='short date' layout='${shortdate}' /> <attribute name='message' layout='${message}' /> </layout> </variable> </nlog>"); // Act & Assert var jsonLayout = Assert.IsType <JsonLayout>(configuration.Variables["myJson"]); Assert.Equal(2, jsonLayout.Attributes.Count); Assert.Equal("short date", jsonLayout.Attributes[0].Name); Assert.NotNull(jsonLayout.Attributes[0].Layout); }
public void ParseNLogInternalLoggerPathTest() { using (new InternalLoggerScope(true)) { var xml = "<nlog internalLogFile='${CurrentDir}test.txt'></nlog>"; var config = XmlLoggingConfiguration.CreateFromXmlString(xml); Assert.Contains(System.IO.Directory.GetCurrentDirectory(), InternalLogger.LogFile); } using (new InternalLoggerScope(true)) { var xml = "<nlog internalLogFile='${BaseDir}test.txt'></nlog>"; var config = XmlLoggingConfiguration.CreateFromXmlString(xml); Assert.Contains(AppDomain.CurrentDomain.BaseDirectory, InternalLogger.LogFile); } using (new InternalLoggerScope(true)) { var xml = "<nlog internalLogFile='${TempDir}test.txt'></nlog>"; var config = XmlLoggingConfiguration.CreateFromXmlString(xml); Assert.Contains(System.IO.Path.GetTempPath(), InternalLogger.LogFile); } #if !NETSTANDARD1_3 using (new InternalLoggerScope(true)) { var xml = "<nlog internalLogFile='${ProcessDir}test.txt'></nlog>"; var config = XmlLoggingConfiguration.CreateFromXmlString(xml); Assert.Contains(Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess()?.MainModule?.FileName), InternalLogger.LogFile); } #endif using (new InternalLoggerScope(true)) { var userName = Environment.GetEnvironmentVariable("USERNAME") ?? string.Empty; var xml = "<nlog internalLogFile='%USERNAME%_test.txt'></nlog>"; var config = XmlLoggingConfiguration.CreateFromXmlString(xml); if (!string.IsNullOrEmpty(userName)) { Assert.Contains(userName, InternalLogger.LogFile); } } }
public void NDCTopTestTest() { LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@" <nlog> <targets><target name='debug' type='Debug' layout='${ndc:topframes=2} ${message}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); NestedDiagnosticsContext.Clear(); LogManager.GetLogger("A").Debug("0"); AssertDebugLastMessage("debug", " 0"); using (NestedDiagnosticsContext.Push("ala")) { LogManager.GetLogger("A").Debug("a"); AssertDebugLastMessage("debug", "ala a"); using (NestedDiagnosticsContext.Push("ma")) { LogManager.GetLogger("A").Debug("b"); AssertDebugLastMessage("debug", "ala ma b"); using (NestedDiagnosticsContext.Push("kota")) { LogManager.GetLogger("A").Debug("c"); AssertDebugLastMessage("debug", "ma kota c"); using (NestedDiagnosticsContext.Push("kopytko")) { LogManager.GetLogger("A").Debug("d"); AssertDebugLastMessage("debug", "kota kopytko d"); } LogManager.GetLogger("A").Debug("c"); AssertDebugLastMessage("debug", "ma kota c"); } LogManager.GetLogger("A").Debug("b"); AssertDebugLastMessage("debug", "ala ma b"); } LogManager.GetLogger("A").Debug("a"); AssertDebugLastMessage("debug", "ala a"); } LogManager.GetLogger("A").Debug("0"); AssertDebugLastMessage("debug", " 0"); }
public void DifferentConfigurations_UseDifferentDefaultCulture() { var currentCulture = CultureInfo.CurrentCulture; try { // set the current thread culture to be definitely different from the InvariantCulture Thread.CurrentThread.CurrentCulture = GetCultureInfo("de-DE"); var configurationTemplate = @"<nlog useInvariantCulture='{0}'> <targets> <target name='debug' type='Debug' layout='${{message}}' /> </targets> <rules> <logger name='*' writeTo='debug'/> </rules> </nlog>"; // configuration with current culture var configuration1 = XmlLoggingConfiguration.CreateFromXmlString(string.Format(configurationTemplate, false)); Assert.Null(configuration1.DefaultCultureInfo); // configuration with invariant culture var configuration2 = XmlLoggingConfiguration.CreateFromXmlString(string.Format(configurationTemplate, true)); Assert.Equal(CultureInfo.InvariantCulture, configuration2.DefaultCultureInfo); Assert.NotEqual(configuration1.DefaultCultureInfo, configuration2.DefaultCultureInfo); var testNumber = 3.14; var testDate = DateTime.Now; const string formatString = "{0},{1:d}"; AssertMessageFormattedWithCulture(configuration1, CultureInfo.CurrentCulture, formatString, testNumber, testDate); AssertMessageFormattedWithCulture(configuration2, CultureInfo.InvariantCulture, formatString, testNumber, testDate); } finally { // restore current thread culture Thread.CurrentThread.CurrentCulture = currentCulture; } }
public void WebserviceTest_soap11_custom_soapaction() { var configuration = XmlLoggingConfiguration.CreateFromXmlString($@" <nlog throwExceptions='true'> <targets> <target type='WebService' name='ws' url='{getWsAddress(1)}{"api/logdoc/soap11"}' protocol='Soap11' namespace='http://tempuri.org/' methodName ='Ping' preAuthenticate='false' encoding ='UTF-8' > <header name='SOAPAction' layout='http://tempuri.org/custom-namespace/Ping'/> <parameter name='param1' ParameterType='System.String' layout='${{message}}'/> <parameter name='param2' ParameterType='System.String' layout='${{level}}'/> </target> </targets> <rules> <logger name='*' writeTo='ws' /> </rules> </nlog>"); LogManager.Configuration = configuration; var logger = LogManager.GetCurrentClassLogger(); var txt = "test.message"; // Lets tease the Xml-Serializer, and see it can handle xml-tags var count = 1; var expectedHeaders = new Dictionary <string, string> { { "SOAPAction", "http://tempuri.org/custom-namespace/Ping" } }; var context = new LogDocController.TestContext(1, count, true, expectedHeaders, null, null, true, DateTime.UtcNow); StartOwinDocTest(context, () => { logger.Info(txt); }); Assert.Equal <int>(0, context.CountdownEvent.CurrentCount); }
private void InternalLoggingConfigTest(LogLevel logLevel, bool logToConsole, bool logToConsoleError, LogLevel globalThreshold, bool throwExceptions, bool?throwConfigExceptions, string file, bool logToTrace, bool autoShutdown) { var logLevelString = logLevel.ToString(); var internalLogToConsoleString = logToConsole.ToString().ToLower(); var internalLogToConsoleErrorString = logToConsoleError.ToString().ToLower(); var globalThresholdString = globalThreshold.ToString(); var throwExceptionsString = throwExceptions.ToString().ToLower(); var throwConfigExceptionsString = throwConfigExceptions == null ? "" : throwConfigExceptions.ToString().ToLower(); var logToTraceString = logToTrace.ToString().ToLower(); var autoShutdownString = autoShutdown.ToString().ToLower(); using (new InternalLoggerScope(true)) { XmlLoggingConfiguration.CreateFromXmlString($@" <nlog internalLogFile='{file}' internalLogLevel='{logLevelString}' internalLogToConsole='{ internalLogToConsoleString }' internalLogToConsoleError='{internalLogToConsoleErrorString}' globalThreshold='{ globalThresholdString }' throwExceptions='{throwExceptionsString}' throwConfigExceptions='{ throwConfigExceptionsString }' internalLogToTrace='{logToTraceString}' autoShutdown='{autoShutdownString}'> </nlog>"); Assert.Same(logLevel, InternalLogger.LogLevel); Assert.Equal(file, InternalLogger.LogFile); Assert.Equal(logToConsole, InternalLogger.LogToConsole); Assert.Equal(logToConsoleError, InternalLogger.LogToConsoleError); Assert.Same(globalThreshold, LogManager.GlobalThreshold); Assert.Equal(throwExceptions, LogManager.ThrowExceptions); Assert.Equal(throwConfigExceptions, LogManager.ThrowConfigExceptions); Assert.Equal(logToTrace, InternalLogger.LogToTrace); Assert.Equal(autoShutdown, LogManager.AutoShutdown); } }