How to watch your log through your application in Log4Net

Log4Net is an excellent logging system that allows you to clearly see what your application is doing and when, making it very easy to debug your app during development but especially during production. I have previously demonstrated how to use Log4Net in C# which enables you to log output to your console for the former and to a file for the latter, but recently I had a requirement to also log to screen during production. This is how I achieved it:

There is already existing an appender that allows you to log your events to memory; I felt this was a good place to start as it means I can immediately access the events with little fuss, however, it doesn’t contain the ability to throw events when an event is added and as I want to view events in real time this required extending the class:

public class MemoryAppenderWithEvents : MemoryAppender {
    public event EventHandler Updated;

    protected override void Append(log4net.Core.LoggingEvent loggingEvent) {
        // Append the event as usual
        base.Append(loggingEvent);

        // Then alert the Updated event that an event has occurred
        var handler = Updated;
        if (handler != null) {
            handler(this, new EventArgs());
        }
    }
}

This is pretty self explanatory – it simply carries out the usual action of adding the event that occurs but it also calls the Updated event with blank EventArgs (the purpose being to simply alert us).

We then add this MemoryAppenderWithEvents to our Log4Net.config where [namespace] is your working namespace:

<!-- Append to memory (for displaying in log console) -->
<appender name="MemoryAppender" type="[namespace].MemoryAppenderWithEvents" />

NOTE: Todd kindly points out that you may need to add the assembly name after the type, see: http://weblogs.asp.net/tgraham/loading-the-assembly-for-a-custom-log4net-appender

and then within your root tag insert:

<appender-ref ref="MemoryAppender" />

The next step is to create a LogWatcher – this monitors the MemoryAppenderWithEvents for Updated events and reacts when one occurs by throwing its own event. These two classes could probably have been combined but in my case it was best to keep them separate:

public class LogWatcher {
    private string logContent;

    private MemoryAppenderWithEvents memoryAppender;

    public event EventHandler Updated;

    public string LogContent {
        get { return logContent; }
    }

    public LogWatcher() {
        // Get the memory appender
        memoryAppender = (MemoryAppenderWithEvents) Array.Find(LogManager.GetRepository().GetAppenders(), GetMemoryAppender);

        // Read in the log content
        this.logContent = GetEvents(memoryAppender);

        // Add an event handler to handle updates from the MemoryAppender
        memoryAppender.Updated += HandleUpdate;
    }

    public void HandleUpdate(object sender, EventArgs e) {
        this.logContent += GetEvents(memoryAppender);

        // Then alert the Updated event that the LogWatcher has been updated
        var handler = Updated;
        if (handler != null) {
            handler(this, new EventArgs());
        }
    }

    private static bool GetMemoryAppender(IAppender appender) {
        // Returns the IAppender named MemoryAppender in the Log4Net.config file
        if (appender.Name.Equals("MemoryAppender")) {
            return true;
        } else {
            return false;
        }
    }

    public string GetEvents(MemoryAppenderWithEvents memoryAppender) {
        StringBuilder output = new StringBuilder();

        // Get any events that may have occurred
        LoggingEvent[] events = memoryAppender.GetEvents();

        // Check that there are events to return
        if (events != null && events.Length > 0) {
            // If there are events, we clear them from the logger, since we're done with them  
            memoryAppender.Clear();

            // Iterate through each event
            foreach (LoggingEvent ev in events) {
                // Construct the line we want to log
                string line = ev.TimeStamp.ToString("yyyy-MM-dd HH:mm:ss,fff") + " [" + ev.ThreadName + "] " + ev.Level + " " + ev.LoggerName + ": " + ev.RenderedMessage + "\r\n"; 

                // Append to the StringBuilder
                output.Append(line);
            }
        }

        // Return the constructed output
        return output.ToString();
    }
}

So we first of all create the LogWatcher and find the MemoryAppenderWithEvents (in this case named MemoryAppender) and we get any events that may already be in it which are written to our buffer; we then attach a function to the MemoryAppenderWithEvents’ Updated event so that when the MemoryAppenderWithEvents is updated it will again write the events to the buffer but then also call the LogWatcher’s own Updated event.

So now we are collecting events in to a buffer whenever these events occur, we need to actually write them to somewhere. In my case I am writing them to a RichTextBox called LogTextbox (which we will presume already exists); so lets create and initialise the LogWatcher and attach a function to the Updated event:

// Create a LogFileWatcher to display the log and bind the log textbox to it
logWatcher = new LogWatcher();
logWatcher.Updated += logWatcher_Updated;

and lets create the function:

public void logWatcher_Updated(object sender, EventArgs e) {
    UpdateLogTextbox(logWatcher.LogContent);
}

This function simply calls a public form function that will do the actual updating. This is very important because if we update the textbox directly it will throw an error as both items are created on different threads:

public void UpdateLogTextbox(string value) {
    // Check whether invoke is required and then invoke as necessary
    if (InvokeRequired) {

        this.BeginInvoke(new Action(UpdateLogTextbox), new object[] { value });
        return;
    }

    // Set the textbox value
    LogTextbox.Text = value;
}

And we’re done! You should now have a reliable logging textbox that shows all of the events within it that also appear within your console, your textfile and wherever else you have logged events. There are a couple of great additions that you can make to your console log and I will be adding this in some upcoming posts, so keep an eye out if you are interested.

About Stephen Pickett

Stephen Pickett is a programmer, IT strategist and architect, project manager and business analyst, Oracle Service Cloud and telephony expert, information security specialist, all-round geek. He is currently Technical Director at Connect Assist, a social business that helps charities and public services improve quality, efficiency and customer engagement through the provision of helpline services and CRM systems.

Stephen is based in south Wales and attended Cardiff University to study Computer Science, in which he achieved a 2:1 grading. He has previously worked for Think Consulting Solutions, a leading voice on not-for-profit fundraising, Fujitsu Services and Sony Manufacturing UK as a software developer.

Stephen is the developer of ThinkTwit, a WordPress plugin that allows you to display multiple Twitter feeds within a blog.

• View all posts by Stephen Pickett →
• Blog
• Twitter
• Facebook
• Google+