Most useful NLog configurations [closed]

Question

What are the best or most useful configurations for logging with NLog? (These can be simple or complex, as long as they're useful.)

I'm thinking of examples like automatically rolling over log files at a certain size, changing the layout (log message) whether or not there is an exception, escalating the log level once an error has occurred, etc.

Here are some links:

• NLog Demo
• Examples in the source

Answer 1

Some of these fall into the category of general NLog (or logging) tips rather than strictly configuration suggestions.

Here are some general logging links from here at SO (you might have seen some or all of these already):

log4net vs. Nlog

Logging best practices

What's the point of a logging facade?

Why do loggers recommend using a logger per class?

Use the common pattern of naming your logger based on the class Logger logger = LogManager.GetCurrentClassLogger(). This gives you a high degree of granularity in your loggers and gives you great flexibility in the configuration of the loggers (control globally, by namespace, by specific logger name, etc).

Use non-classname-based loggers where appropriate. Maybe you have one function for which you really want to control the logging separately. Maybe you have some cross-cutting logging concerns (performance logging).

If you don't use classname-based logging, consider naming your loggers in some kind of hierarchical structure (maybe by functional area) so that you can maintain greater flexibility in your configuration. For example, you might have a "database" functional area, an "analysis" FA, and a "ui" FA. Each of these might have sub-areas. So, you might request loggers like this:

Logger logger = LogManager.GetLogger("Database.Connect"); Logger logger = LogManager.GetLogger("Database.Query"); Logger logger = LogManager.GetLogger("Database.SQL"); Logger logger = LogManager.GetLogger("Analysis.Financial"); Logger logger = LogManager.GetLogger("Analysis.Personnel"); Logger logger = LogManager.GetLogger("Analysis.Inventory"); 

And so on. With hierarchical loggers, you can configure logging globally (the "*" or root logger), by FA (Database, Analysis, UI), or by subarea (Database.Connect, etc).

Loggers have many configuration options:

<logger name="Name.Space.Class1" minlevel="Debug" writeTo="f1" />  <logger name="Name.Space.Class1" levels="Debug,Error" writeTo="f1" />  <logger name="Name.Space.*" writeTo="f3,f4" /> <logger name="Name.Space.*" minlevel="Debug" maxlevel="Error" final="true" />  

See the NLog help for more info on exactly what each of the options means. Probably the most notable items here are the ability to wildcard logger rules, the concept that multiple logger rules can "execute" for a single logging statement, and that a logger rule can be marked as "final" so subsequent rules will not execute for a given logging statement.

Use the GlobalDiagnosticContext, MappedDiagnosticContext, and NestedDiagnosticContext to add additional context to your output.

Use "variable" in your config file to simplify. For example, you might define variables for your layouts and then reference the variable in the target configuration rather than specify the layout directly.

  <variable name="brief" value="${longdate} | ${level} | ${logger} | ${message}"/>   <variable name="verbose" value="${longdate} | ${machinename} | ${processid} | ${processname} | ${level} | ${logger} | ${message}"/>   <targets>     <target name="file" xsi:type="File" layout="${verbose}" fileName="${basedir}/${shortdate}.log" />     <target name="console" xsi:type="ColoredConsole" layout="${brief}" />   </targets> 

Or, you could create a "custom" set of properties to add to a layout.

  <variable name="mycontext" value="${gdc:item=appname} , ${mdc:item=threadprop}"/>   <variable name="fmt1withcontext" value="${longdate} | ${level} | ${logger} | [${mycontext}] |${message}"/>   <variable name="fmt2withcontext" value="${shortdate} | ${level} | ${logger} | [${mycontext}] |${message}"/> 

Or, you can do stuff like create "day" or "month" layout renderers strictly via configuration:

  <variable name="day" value="${date:format=dddd}"/>   <variable name="month" value="${date:format=MMMM}"/>   <variable name="fmt" value="${longdate} | ${level} | ${logger} | ${day} | ${month} | ${message}"/>   <targets>     <target name="console" xsi:type="ColoredConsole" layout="${fmt}" />   </targets> 

You can also use layout renders to define your filename:

  <variable name="day" value="${date:format=dddd}"/>   <targets>     <target name="file" xsi:type="File" layout="${verbose}" fileName="${basedir}/${day}.log" />   </targets> 

If you roll your file daily, each file could be named "Monday.log", "Tuesday.log", etc.

Don't be afraid to write your own layout renderer. It is easy and allows you to add your own context information to the log file via configuration. For example, here is a layout renderer (based on NLog 1.x, not 2.0) that can add the Trace.CorrelationManager.ActivityId to the log:

  [LayoutRenderer("ActivityId")]   class ActivityIdLayoutRenderer : LayoutRenderer   {     int estimatedSize = Guid.Empty.ToString().Length;      protected override void Append(StringBuilder builder, LogEventInfo logEvent)     {       builder.Append(Trace.CorrelationManager.ActivityId);     }      protected override int GetEstimatedBufferSize(LogEventInfo logEvent)     {       return estimatedSize;     }   } 

Tell NLog where your NLog extensions (what assembly) like this:

  <extensions>     <add assembly="MyNLogExtensions"/>   </extensions> 

Use the custom layout renderer like this:

  <variable name="fmt" value="${longdate} | ${ActivityId} | ${message}"/> 

Use async targets:

<nlog>   <targets async="true">     <!-- all targets in this section will automatically be asynchronous -->   </targets> </nlog> 

And default target wrappers:

<nlog>     <targets>       <default-wrapper xsi:type="BufferingWrapper" bufferSize="100"/>       <target name="f1" xsi:type="File" fileName="f1.txt"/>       <target name="f2" xsi:type="File" fileName="f2.txt"/>     </targets>     <targets>       <default-wrapper xsi:type="AsyncWrapper">         <wrapper xsi:type="RetryingWrapper"/>       </default-wrapper>       <target name="n1" xsi:type="Network" address="tcp://localhost:4001"/>       <target name="n2" xsi:type="Network" address="tcp://localhost:4002"/>       <target name="n3" xsi:type="Network" address="tcp://localhost:4003"/>     </targets>   </nlog> 

where appropriate. See the NLog docs for more info on those.

Tell NLog to watch and automatically reload the configuration if it changes:

<nlog autoReload="true" />  

There are several configuration options to help with troubleshooting NLog

<nlog throwExceptions="true" /> <nlog internalLogFile="file.txt" /> <nlog internalLogLevel="Trace|Debug|Info|Warn|Error|Fatal" /> <nlog internalLogToConsole="false|true" /> <nlog internalLogToConsoleError="false|true" /> 

See NLog Help for more info.

NLog 2.0 adds LayoutRenderer wrappers that allow additional processing to be performed on the output of a layout renderer (such as trimming whitespace, uppercasing, lowercasing, etc).

Don't be afraid to wrap the logger if you want insulate your code from a hard dependency on NLog, but wrap correctly. There are examples of how to wrap in the NLog's github repository. Another reason to wrap might be that you want to automatically add specific context information to each logged message (by putting it into LogEventInfo.Context).

There are pros and cons to wrapping (or abstracting) NLog (or any other logging framework for that matter). With a little effort, you can find plenty of info here on SO presenting both sides.

If you are considering wrapping, consider using Common.Logging. It works pretty well and allows you to easily switch to another logging framework if you desire to do so. Also if you are considering wrapping, think about how you will handle the context objects (GDC, MDC, NDC). Common.Logging does not currently support an abstraction for them, but it is supposedly in the queue of capabilities to add.