We've done a lot log4net configuration in the last few tutorials; time to mix in some code and discuss loggers. This post is meant to show you the most common pattern of logger use.
Crack open Visual Studio, create a new console project, and add a reference to the log4net assembly.
Add the following application configuration file to the project:
<configuration>
<configSections>
<section name="log4net"
type="log4net.Config.Log4NetConfigurationSectionHandler, log4net"/>
</configSections>
<log4net>
<appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="%logger [%level]- %message%newline" />
</layout>
</appender>
<root>
<level value="ALL" />
<appender-ref ref="ConsoleAppender" />
</root>
</log4net>
</configuration>
Add the following code to your program.cs file:
namespace Tutorial5_Loggers
{
class Program
{
private static log4net.ILog Log = log4net.LogManager.GetLogger( System.Reflection.MethodBase.GetCurrentMethod().DeclaringType );
static void Main( string[] args )
{
log4net.Config.XmlConfigurator.Configure();
Log.Info( "this is an info message" );
Console.ReadLine();
}
}
} The logger object is created on line 5 via a the call to LogManager.GetLogger. Compile and run and check out the output; it'll be similar to the following:
Tutorial5_Loggers.Program [INFO]- this is an info message
The first item in the log entry printed to the console is the name of the logger object that issued the log entry. Because GetLogger was passed a reference to my Program type, the logger name is the fully qualified type name of the Program object.
Add another class to the project:
namespace Tutorial5_Loggers
{
class MyClass
{
private static log4net.ILog Log = log4net.LogManager.GetLogger( System.Reflection.MethodBase.GetCurrentMethod().DeclaringType );
public static void WriteLog()
{
Log.Info( "this is an info message" );
}
}
} and add a call to MyClass.WriteLog to your Main method (see line 7 below):
static void Main( string[] args )
{
log4net.Config.XmlConfigurator.Configure();
Log.Info( "this is an info message" );
MyClass.WriteLog();
Console.ReadLine();
} Compile and run, and note the logger name in the second log statement matches the type name of MyClass:
Tutorial5_Loggers.Program [INFO]- this is an info message
Tutorial5_Loggers.MyClass [INFO]- this is an info message
Hierarchical Logger Configuration
You can use loggers this way to isolate logging concerns across your objects, and I wholly recommend you do so. This will enable you to throttle and direct log output from individual loggers using log4net's hierarchical configuration mechanism.
Update your app.config to the following:
<configuration>
<configSections>
<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net"/>
</configSections>
<log4net>
<appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="%logger [%level]- %message%newline" />
</layout>
</appender>
<appender name="FileAppender" type="log4net.Appender.FileAppender">
<file value="log-file.txt" />
<appendToFile value="false"/>
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="%logger [%level]- %message%newline" />
</layout>
</appender>
<root>
<level value="ALL" />
</root>
<logger name="Tutorial5_Loggers">
<level value="ALL" />
<appender-ref ref="FileAppender" />
</logger>
<logger name="Tutorial5_Loggers.Program">
<level value="ALL" />
<appender-ref ref="ConsoleAppender" />
</logger>
<logger name="Tutorial5_Loggers.MyClass">
<level value="ALL" />
</logger>
</log4net>
</configuration>
On line 12 we add a file appender to the mix; lines 23-33 provide configuration for specific logger objects. Note that the logger names correspond directly to the namespace-qualified type names and namespaces from our project. Specifically:
- on line 23 a logger is configured specifically for the "Tutorial5_Loggers" namespace; this logger is configured to write logs to the file appender;
- on line 27, a logger is configured for the Program class; this logger is configured to write logs to the console;
- on line 31, a logger is configured for the MyClass class; this logger is not configured with an appender.
Compile and run, and you'll notice that:
- the console output displays only the log statement from the Program class;
- a "log-file.txt" file is written in the application folder, and this file contains the log statements from both the Program and MyClass types.
Now change the level value for the Tutorial5_Loggers.MyClass from ALL to OFF:
<logger name="Tutorial5_Loggers.MyClass">
<level value="OFF" />
</logger>
Compile and run, and note that the log-file.txt file no longer contains the log statement from the MyClass object.
This hierarchical configuration system can be incredibly useful; a common practice is to disable logging of "verbose" objects by targeting their specific type with a logging level set to OFF; another is to provide a "specific-needs" logger configured with a special appender, such as a gateway to the windows event log or a remote log viewer. However, the system has a few caveats you need to know about:
- appenders accumulate through the hierarchy: if the Program class and Tutorial5_Logger namespace are each configured to append to the console, any log from the Program class will show up twice in the console (once for the class logger and once for the namespace logger);
- logger levels deeper in the hierarchy trump the shallow ones: if the Program class logging level is set to ALL and the Tutorial5_Logger namespace logging level is set to OFF, logs from the program class are still written to the appenders configured for Tutorial5_Logger.
Coming Up
The first 5 tutorials have given you some pretty heavy-hitting abilities. Next time I'll discuss associating context to log messages, which can provide invaluable debugging information.