Introduction
I was getting close to deploying a new ASP.NET web application, and needed a good, solid logger. I had written my own simple logger when I started the project, but it just wasn't very clean, easy to manage, or configurable. I'd seen many references to log4net scattered about, and decided to check it out. And, I'm glad I did. In a few hours, I was up and running. It was a bit difficult at first as there are so many different ways to use it and a lot of documentation (a good thing). Finding the correct configuration took a little effort, but was well worth it.
If you're new to log4net, you may want to start here: A brief introduction to the log4net logging library, using C#. There are quite a few other great articles surrounding log4net on the CodeProject. Just do a search, and you'll find many.
After setting up a few basic file and email loggers, I started looking at all the other loggers (a.k.a. Appenders) that log4net offered. I thought it would be great to have a real time console showing me what was happening after the application was deployed. The UDP logger seemed interesting, but I didn't know enough about log4net to imagine how I could use it. So, I searched around a bit to see if anyone had any example uses. I came across the Log4NetViewer. It's a simple WinForm app that receives log4net messages sent from the UdpAppender. Pretty neat, eh? Now, I could remotely monitor my web applications. So, I set it up and used it for a while in my dev environment. It worked well, but I really didn't like the way it displayed the log messages. It uses a grid to display the log. A new row is appended to the grid when a new log message is received. The problem though, is that long messages, like exceptions, are hard to read. You either had to scroll through the cell, or copy/paste the message. Even worse, no source code! Anyway, I let the subject rest, and moved on to more important tasks.
A while later, while making some configuration changes to my log4net setup, I came across the ConsoleAppender and, the even better, ColoredConsoleAppender. Who doesn't love color? Maybe I could monitor my web app's log messages in a log4net console window? The messages would be easy to read, and could even be color coded. I started digging around for some samples and realized that the console loggers cannot directly work with ASP.NET applications. There really is no console in log4net. No console will magically pop-up when you add the ConsoleAppender to your log4net configuration. A console would need to run in the same process or context as the ASP application. It cannot, but does it really need to?
No. Of course, not...
Ah ha! I recalled the UdpAppender. I could create a .NET console application and use the System.Net.Sockets.UdpClient to listen for UDP log messages sent from my ASP.NET application. Just like the Log4NetViewer. Then, use the ColoredConsoleAppender to write them to the console window. A couple hours later... Presto.
Using the code
The code for the console app is pretty simple:
<Assembly: log4net.Config.XmlConfigurator(Watch:=True)>
Imports System.Net.Sockets
Imports System.Net
Module UdpLogListener
Private ReadOnly Log As log4net.ILog = _
log4net.LogManager.GetLogger( _
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType)
Sub Main()
Dim Port As Integer = 8081
Dim Sender As IPEndPoint
Dim Client As UdpClient
Dim Buffer As Byte()
Dim LogLine As String
Try
Sender = New IPEndPoint(IPAddress.Any, 0)
Client = New UdpClient(Port)
While True
Buffer = Client.Receive(Sender)
LogLine = System.Text.Encoding.Default.GetString(Buffer)
If LogLine.IndexOf("{INFO}") >= 0 Then
Log.Info(LogLine.Replace("{INFO}", "[I] "))
ElseIf LogLine.IndexOf("{DEBUG}") >= 0 Then
Log.Debug(LogLine.Replace("{DEBUG}", "[D] "))
ElseIf LogLine.IndexOf("{ERROR}") >= 0 Then
Log.Error(LogLine.Replace("{ERROR}", "[E] "))
ElseIf LogLine.IndexOf("{WARN}") >= 0 Then
Log.Warn(LogLine.Replace("{WARN}", "[W] "))
Else
Log.Warn(LogLine)
End If
End While
Catch e As Exception
Console.WriteLine(e)
Console.WriteLine(vbCrLf & _
"Press any key to close...")
Console.ReadLine()
End Try
End Sub
End Module
Configure the ColoredConsoleAppender and set the log-level colors. The following goes in your App.config:
<configSections>
<section name="log4net"
type="System.Configuration.IgnoreSectionHandler" />
</configSections>
<log4net>
<appender name="ColoredConsoleAppender"
type="log4net.Appender.ColoredConsoleAppender">
<mapping>
<level value="INFO" />
<foreColor value="White, HighIntensity" />
<backColor value="Green" />
</mapping>
<mapping>
<level value="DEBUG" />
<foreColor value="White, HighIntensity" />
<backColor value="Blue" />
</mapping>
<mapping>
<level value="WARN" />
<foreColor value="Yellow, HighIntensity" />
<backColor value="Purple" />
</mapping>
<mapping>
<level value="ERROR" />
<foreColor value="Yellow, HighIntensity" />
<backColor value="Red" />
</mapping>
<layout
type="log4net.Layout.PatternLayout">
<conversionPattern value="%message%newline" />
</layout>
</appender>
<root>
<level value="ALL" />
<appender-ref ref="ColoredConsoleAppender" />
</root>
</log4net>
Lastly, in your ASP.NET application, configure a source UdpAppender to send UDP log messages to your console. Add the following to your log4net config file (see sample application for full config). There a several ways to configure log4net. If you're using a different method, you'll only need the <appender...> section below, and a <appender-ref ref="UdpAppender"> in your root. Remember to match the RemotePort with the UdpClient port in your console app. Also, note that you can format the pattern layout however you like, and even add delimiters and place holders that can be parsed by the client. Below, the {%level} value is replaced in the main loop before being written to the screen. Additional information on the PatternLayout syntax can be found in the log4net SDK PatternLayout class. Note that the layout conversionPattern above (in the console's App.config) has no pattern formatting. The formatting should be set at the source UdpAppender pattern layout config. I'm sure you can use other layout types as well. There are quite a few.
<log4net>
<appender name="UdpAppender" type="log4net.Appender.UdpAppender">
<param name="RemoteAddress" value="localhost" />
<param name="RemotePort"
value="8081" />
<layout type="log4net.Layout.PatternLayout"
value="{%level}%date{MM/dd HH:mm:ss} - %message" />
</appender>
<root>
<level value="ALL" />
<appender-ref ref="UdpAppender" />
</root>
</log4net>
Points of interest
The UdpAppender gives great flexibility in bridging remote log viewers and writers. Like the Log4NetViewer, WinForms clients can be created as well as Console clients, as seen here. Even remote file loggers. You simply need a UDP client and log4net to broadcast, capture, and rewrite log messages. Also, the source UdpAppender can be configured to broadcast log messages to the entire subnet. This allows you to setup multiple client loggers in multiple locations, doing multiple things.
On the flip side, the UDP protocol is meant only to broadcast, there is no validation between the sender and the receiver. So, there is no guarantee that messages will be received or even received in the same order as sent. But that's okay with me, the RollingFileAppender doesn't miss anything.
I hope you enjoyed this article. This is my first article post, so I thought I would keep the topic simple... I think.
History
- 01-26-2007 - Initial creation.
