Slogger - The simple extensible logger

• Download sample exe - 9 KB
• Download source - 31 Kb

Introduction

This article introduces a small and simple library to help logging and instrumentation in your applications. Having recently reviewed the area of logging and instrumentation, I discovered some very complete libraries, such as the Enterprise Instrumention Framework components and the Microsoft Logging Block. Although these libraries were vast and feature complete, they were overkill for the relativly simple logging that I needed. I created the Slogger library for my own use and have put it here as it may be useful to others.

Using the code

The Slogger is a two part library containg the core library, and a library containing the Sink objects. The supplied solution also includes a sample application that demonstrates writing Errors and Events to the Event Log. To run the sample application, simply build the supplied solution with Visual Studio .NET 2003.

The library is driven by an XML file that describes two major parts, Events and Sinks. Events are categorised er, events. To give an example, an event can be called ApplicationError or perhaps just Error or Information. Sinks are where an event is consumed. Examples of Sinks could be where the information in an event is written to the disk or event log.

Event are are linked to one or more Sinks. In the sample file, we have an event named Error. This event is wired to two Sinks, EventLogInformation and FileLog. This means that when an Error event is generated, it will be consumed by the EventLogInformation and FileLog sinks which both in turn do something with the event. Here is an excerpt from the sample file that describes an event and how it is linked to two sinks: <

<Event Type="Information">
    <Sink Name="EventLogInformation" />
    <Sink Name="FileLog" />
 </Event>

Below is an excerpt from the sample file that describes the sinks:

<Sink Type="EventLogInformation">
  <Class Name="Slogger.Sinks.EventLogSink, Slogger.Sinks">
    <InitialiserParameter Index="0" Name="EventLogSourceName">
         Slogger Samples</InitialiserParameter>
    <InitialiserParameter Index="1" Name="EventLogEntryTypeEnumeration">
         Information</InitialiserParameter>
  </Class>
</Sink>

The Sink described above is called EventLogInformation and has a class name of EventLogSink in the Slogger.Sinks assembly. It takes two paramaters that are passed to the Initialise method of the class. Below is the sample code that initialises the library with the settings file and fires two events.

Trace.Listeners.Add( new SloggerListener( 
    @"..\..\samples\cs\EventLogAndFileLog\settings.xml"  ) ); 

That's it. The library is now initialized. Of course, there's a few house-keeping things that must be done, like adding a reference to the System.Diagnostics namespace and setting up event log sources:

using System.Diagnostics ;
      if ( !EventLog.SourceExists("Slogger Samples" )) 
        EventLog.CreateEventSource( "Slogger Samples", "Application") ;

Run the sample application. It puts two entries in the event log. Not much of a sample, but remember apart from house-keeping code, the entries got the event log with just two actual lines of code and a bunch of settings in an XML file.

The Slogger library is extensible. It can load your custom Sink classes and pass event information to them. Below is the interface that your custom classes must implement in order for the Slogger library to be able to load an initialize them:

public interface ISink
{
  void Initialise( SinkManager sinkManager, params object[] arguments) ;
  void Write( string message ) ;
  void WriteLine( string message ) ;
}

Each of your classes must implement the above methods. The Write and WriteLine have been implemented. Other overrides from the

Trace 

class have not yet been implemented, but should be simple to add should you need them. The Slogger library will create your class and pass any constructor parameters (if any are specified in the XML). Once constructed, it will call Initialize on your class, again, with any parameters you may have specified in the XML. The XML below is used in the sample application. This XML describes the FileLog sink and specifies the parameters to pass to the constructor of the FileLogSink class:

<Sink Type="FileLog">
  <Class Name="Slogger.Sinks.FileLogSink, Slogger.Sinks">
    <ConstructorParameter Index="0" Name="Filename">
          c:\out.txt</ConstructorParameter >
  </Class>
</Sink>

Points of Interest

Whilst this library is only small (and simple), it does solve a problem many will face. I learnt that the Microsoft Logging Block is reliant on EIF and Web Services Enhancements 2.0 Technology Preview. This library is ideal for those who want simple and light logging without the overhead of involved set-up procedures and reliance (if only a build reliance) on technology preview code.

History

This is the first release of this library. I may update the core

ISink 

interface in the future to support all of the overrides available to the Trace.WriteLine method. It would be nice for those who create their own custom Sink classes to share them with the community.