Logs and Traces in .Net
I need to add tracing capabilities to my current app, just the ability to set an error level (INFO, WARNING, ERROR) to track the execution of one request in a simple text file, so I started to look for some implementations, I've found two main frameworks:
- log4net [https://logging.apache.org/log4net/]
- Logging Application Block. [https://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnpag/html/Logging.asp?frame=true]
The first one is an open source project based on the popular log4java, and the second one is a reference block from PAG group (MSDN). I had to discard log4net just because it's Apache License. So I started to dig into the Loggin Application Block.
To install the LogginAppBlock you need first to get:
EIF has a lot of functionality (async logging, WMI Events and so on) but the download page for WSE claims:
...The technology preview of WSE 2.0 is unsupported and is not licensed for production use. For supported bits, use WSE 1.0. ..
So I had to discard this option too. And start to look at the System.Diagnostics Namespace to see which functionality I can reuse, I found it has a lot of useful things:
· TraceLeves to define the detail of your logs
· TraceListeners to specify the log destination
· Configurable Mechanism to define TraceLevels and TraceListeners
So I started to write some unit test to validate this features. The configuration file for the unit tests looks like this:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.diagnostics>
<switches>
<add name="TraceEnabled" value="1" />
<add name="TraceLevel" value="4" />
</switches>
<trace autoflush="true" indentsize="1">
<listeners>
<add name="FileTrace" type="System.Diagnostics.TextWriterTraceListener"
initializeData="d:\Demo.trace" />
</listeners>
</trace>
</system.diagnostics>
</configuration>
To write the Asserts, the first attempt was to read the contents of the Demo.trace file to see if the contents are correctly logged. However I always get an IOException:
System.IO.IOException : The process cannot access the file " .\Demo.trace" because it is being used by another process.
So I need another listener controlated by the Fixture where the Trace Methods can write and the test can read:
[TestFixture]
public class TrazedClassFixture
{
Stream logStream;
[TestFixtureSetUp]
public void initTestFixture()
{
logStream = new MemoryStream();
Trace.Listeners.Add(
new TextWriterTraceListener(logStream));
}
[TestFixtureTearDown]
public void Reset()
{
logStream.Close();
}
[Test]
public void LogWarning()
{
Log.Warning("WarningMessage");
logStream.Position = 0;
Assert.AreEqual(“WARNING: WarningMessage”,
readStream(logStream));
}
}
After running the tests from NUnit GUI I have the green bar and the file Demo.trace is created with the log information.
Now I need to mock the TraceLevel configuration, so my TraceLogger will accept a TraceSwitch instance in the ctor, to allow testing these features without changing the config.file.
TraceSwitch config = new TraceSwitch("TestSwitch", "ConfigurableSwitch");
ILogger logger = new TraceLogger(config, "TEST");
So each test can configure the tracelevel.
[Test]
public void ConfigOnlyError()
{
config.Level = TraceLevel.Error;
logger.Info("msg1");
logger.Warning("msg2");
logger.Error("msg3");
Assert.AreEqual("msg3", actual());
}
private string actual()
{
string result = String.Empty;
memory.Position = 0;
using (StreamReader sr = new StreamReader(memory))
{
result = sr.ReadToEnd();
}
return result;
}
The next step is to create a Log from the ASP.NET Runtime, so I create a WebApp and call Log.Warning Again. My WebApp consists of one WebMethod
[WebMethod]
public string HelloWorld()
{
Log.Warning("Hello WS");
return "Hello World";
}
Once the WebMethod is called it throws the next exception
System.UnauthorizedAccessException: Access to the path 'C:\WINDOWS\system32\Demo.trace' is denied.
Obviously we should define the full path to the log file:
<listeners>
<add name="FileTrace" type="System.Diagnostics.TextWriterTraceListener"
initializeData="d:\Logs\Demo.trace" />
</listeners>
After giving permissions to the ASPNET user to the folder d:\Logs everythings works but the absolute path in the configuration file is something we must avoid, but this is another story.
At least, the code for my Logger class looks like this.
/// <summary>
/// Helper Class to Write Log Files based on .NET Trace Settings
/// </summary>
public class TraceLogger : ILogger
{
string _category = String.Empty;
TraceSwitch traceConfig;
/// <summary>
/// Facory to create new Logger Object
/// </summary>
/// <param name="name">Used as category of traces</param>
/// <returns>New Logger Object</returns>
public static ILogger GetLogger(string name)
{
return new TraceLogger(name);
}
/// <summary>
/// Initialize the LogWriter reading settings from .Config
/// </summary>
public TraceLogger(string category)
{
_category = category;
traceConfig = new TraceSwitch("TraceLevel", "Controls the detail of the log");
}
/// <summary>
/// Initialize the LogWriter with specified TraceSwitches
/// </summary>
/// <param name="config"></param>
/// /// <param name="category"></param>
public TraceLogger(TraceSwitch config, string category)
{
_category = category;
traceConfig = config;
Trace.AutoFlush = true;
}
public void Error(object message)
{
if ( traceConfig.TraceError)
{
writeWithCurrentTime("ERROR: " + message.ToString());
}
}
public void Error(object message, Exception exception)
{
Error(message);
if ( traceConfig.TraceError)
{
writeException(exception);
}
}
public void Warning(object message)
{
if ( (traceConfig.TraceWarning))
{
writeWithCurrentTime("WARNING: " + message.ToString());
}
}
public void Warning(object message, Exception ex)
{
Warning(message);
if ( (traceConfig.TraceWarning))
{
writeException(ex);
}
}
public void Info(object message)
{
if ((traceConfig.TraceInfo))
{
writeWithCurrentTime("INFO: " + message.ToString());
}
}
public void Info(object message, Exception ex)
{
Info(message);
if ((traceConfig.TraceInfo))
{
writeException(ex);
}
}
private void writeWithCurrentTime(string message)
{
string now = System.DateTime.Now.ToString("yy-MM-dd hh:mm:ss");
Trace.WriteLine(now + " " + message, _category);
}
private void writeException(Exception exception)
{
Exception ex = exception;
Trace.Write("EXCEPTION: ");
Trace.IndentLevel++;
while (ex != null)
{
string msg = ex.Message;
string stack = ex.StackTrace;
Trace.IndentLevel++;
Trace.WriteLineIf(msg.Length>0, msg);
Trace.WriteLineIf(stack!=null,stack);
Trace.IndentLevel--;
ex = ex.InnerException;
}
Trace.IndentLevel--;
}
}
Comments
- Anonymous
May 07, 2004
While not intending to start an online argument on your blog regarding GPL vs. other licensing, I'd like to point out that Log4net isn't GPL licensed as you stated. It has an Apache license which is friendlier than GPL. - Anonymous
May 09, 2004
It has been fixed now. Thanks - Anonymous
July 15, 2004
Great article! I found it very useful. I've also been looking into different tracing frameworks. I'll definitely check out System.Diagnostics. - Anonymous
May 07, 2005
One year ago I wrote about the tracing mechanism of .Net, http://blogs.msdn.com/rido/archive/2004/05/07/LogsAndTraces.aspx.... - Anonymous
May 07, 2005
The TextWriterTraceListener provided with System.Diagnostics, has several limitations, this article discusses the implementation of a new TraceListener that allows to rotate the logs based on the current DateTime - Anonymous
September 25, 2007
The TextWriterTraceListener provided with System.Diagnostics, has several limitations, this article discusses the implementation of a new TraceListener that allows to rotate the logs based on the current DateTime