Create a Logger using the Trace Listener in C#

Files and Directories, Tutorials

When writing software for the commercial world it is crucial your application can log errors, be it to the database, or to a text file, or even to the Windows Event Log if necessary. The .NET Framework contains a mechanism called a Trace Listener. This Listener is an object which directs the trace output to an appropriate target, such as an error log for example.

In this article I am going to show you how to use the Trace Listener to record your application’s errors to an error log.

To begin this example create a console application and add an App.config file to your project. We are going to use the App.config file to tell our application that it should create a trace listener on start-up. Amend the XML code of your App.config file to look like the below example.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.diagnostics>
    <trace autoflush="true" indentsize="4">
      <listeners>
        <add name="myListener" type="System.Diagnostics.TextWriterTraceListener" initializeData="application.log" />
        <remove name="Default" />
      </listeners>
    </trace>
  </system.diagnostics>
</configuration>

As you can see, we are adding a listener of type System.Diagnostics.TextWriterTraceListener which is set to write to a log file called application.log. Also note that in the <trace> node we are setting the autoflush attribute to true. When set to true this attribute tells the listener to flush the buffer after every write operation. For this example it is great but for real world applications you probably would want to set this to false to limit disk read and write operations.

Now in your static Main method you can write to the log using the Trace class as shown below.

static void Main(string[] args)
{
    Trace.WriteLine("Application started.", "MyApp");

    Trace.WriteLine("working...", "MyApp");

    Trace.WriteLine("Application finished.", "MyApp");
}

If we open the application.log file created automatically by the listener right after we run the above code we will find the following in the file:

MyApp: Application started.
MyApp: working...
MyApp: Application finished.

As you can see it’s quite easy to write to the log file. We didn’t even have to open a FileStream to write to the file because it was all done for us automatically by the listener.

This logger we just created is quite crude since we are not recording the date and time of the error, nor are we recording the source. So let’s extend the concept a little by creating a small logger class as shown below.

using System;
using System.Diagnostics;

public static class Logger
{
    public static void Error(string message, string module)
    {
        WriteEntry(message, "error", module);
    }

    public static void Error(Exception ex, string module)
    {
        WriteEntry(ex.Message, "error", module);
    }

    public static void Warning(string message, string module)
    {
        WriteEntry(message, "warning", module);
    }

    public static void Info(string message, string module)
    {
        WriteEntry(message, "info", module);
    }

    private static void WriteEntry(string message, string type, string module)
    {
        Trace.WriteLine(
                string.Format("{0},{1},{2},{3}",
                              DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                              type,
                              module,
                              message));
    }
}

The above Logger class has four public static methods – Warning, Info, and an overloaded Error method. Each of these methods calls the private WriteEntry method which actually writes to the log through the Trace class. As you can see here we are writing the date and time, the entry type (“error”, “warning”, or “info”), the module where the error occurred, and the actual error message.

Now to use this class we can do the following:

static void Main(string[] args)
{
    try
    {
        Logger.Info("Application started.", "MyApp");
        Logger.Info("working...", "MyApp");
        Logger.Warning("Application about to exit!", "MyApp");
        Logger.Info("Application finished.", "MyApp");

        throw new Exception();
    }
    catch (Exception ex)
    {
        Logger.Error(ex, "MyApp");
    }
}

The above code would produce the following log:

2009-09-16 23:02:04,info,MyApp,Application started.
2009-09-16 23:02:04,info,MyApp,working...
2009-09-16 23:02:04,warning,MyApp,Application about to exit!
2009-09-16 23:02:04,info,MyApp,Application finished.
2009-09-16 23:02:04,error,MyApp,Exception of type 'System.Exception' was thrown.

And there you have it – you now know how to use the Trace Listener in C# and how to create a simple logger class. Obviously the Logger class we created can be enhanced a lot more. For example you could add code to wrap the log file after it grows to 5MB. You could also add code to log the thread which the error occurred on. There is a large number of amendments you could do to make this class better.

I hope you enjoyed this article. Feel free to leave any comments below or if you want you can contact me through my contact page. Also, if you haven’t already subscribed to my rss feed, please do so – Grab RSS Feed.

Dave

50 comments… add one
  • David Link Reply

    Perfect example for what I needed. Good and consise explaination too. Thanks!

  • Allan Pedersen Link Reply

    Hi! Great site, great tutorial, it really explained it alle very well… I can only hope for a follow-up on this tracing subject. I would like to have your thoughts about how you would handle the trace log once the software is published…

    Thanks again! I will be looking into your site from time to time from now on… 🙂

    • Thanks for your comment. I’m glad you found the tutorial helpful.

      I usually handle the trace log in two different ways depending on the application. If the application writes massive amounts of logs to the trace file I would create a new file each day, and then either compress them or archive them every month or so. If the application only writes errors to the log file I would start a new file after it reaches about 5Mb and then archive those every year. It really depends on how much your application will be writing to the log file.

      • Allan Pedersen Link Reply

        What is your best practise for retrieving the log files? I like to get the log files whin an error occurs so I am sending them to my self by mail from the program…

        • Usually I do the same. When sending errors by email you will immediately know when something goes wrong, and it’s quite simple to implement and works most of the time.

          I have also worked on systems where error logs are automatically downloaded from our clients’ servers over ftp on a weekly basis. Also, what you could do instead of sending emails is open a socket from the client’s pc to your server and send the error message over tcp. Then you could store it in a database on your server, but this does require you to have a server with a static ip always online.

          I am sure there are other methods worth exploring, but if you are not expecting many errors and only have a few installations of your application out there, I would stick with receiving errors by email. I would create an email account just for this purpose though, so as not to clutter my personal mailbox.

      • Vijayakumar Link Reply

        Nice Article. But how can we configure the log file name. Change the name daily….

  • Allan Pedersen Link Reply

    Thanks, good to hear i am not way of track by mailing myself error/log reports… 🙂 (My company is not that big and installations is relatively limited). Logging everything to a database might be a bit to heavy net usage for my liking.

    Thanks again for your tutorial and for your comments….

  • xiaokang Link Reply

    Very good!Very Helpful!
    If want to ad date information in log, can add this config:

    but ,log will by large.
    i want to close trace output when not necessary ,how can i do?
    thank you!

  • Nice article a better way to explain..

  • redcode Link Reply

    nice tutorial, could you please show how to store information in a database ??
    thank you,
    Bob

  • Patel Rikin Link Reply

    thanks a lot…..

    nice article …. i things this one best article…….

    i m lot of search but this article whatever explain it very quickly understandable……..

  • Gupreet Link Reply

    Very nice article. Nice concise and to the point.

  • TheClever Link Reply

    Hello,
    I did not success. I did what you said but I can see the application.log
    What can be the problem?
    I am using SharpDeveloper,
    Thanks

  • TheClever Link Reply

    Ok, I test it on VS 2010 Express and it workss vey well. Thanks.
    But now how can I customized to write the log file to a specific directory for example. I want the application.log file to be store in the Log directory:

    It does not create anything, no log directory
    How can I set it?
    Thanks

  • Fraz Link Reply

    Nice article! Got 2 questions though.

    Can u specify which file it writes to at run time?

    How would u turn the logging off? would u just comment out ?

  • Philip Wade Link Reply

    After trawling through a dozen or more ‘tutorials’, I found this one which explains Trace logging clearly, concisely, and has an example that works. Splendid.

  • mcartur Link Reply

    This is exactly was I was looking for¡¡ Simple and clear.

    Thanks a lot¡¡

  • samashti Link Reply

    I did as you said ,but no log file as been generated as such..
    What could be the problem?
    Plz help me..

  • Sonam Kumar Link Reply

    Thank you so much! Just what I wanted and you explained to so well. Sweet!

  • Rakesh Link Reply

    neatly written and clearly explained, this is how articles should be written

  • You have remarkable information on this web-site.
    Thanks for sharing here

  • suresh Link Reply

    Its a Good Information and much useful one can u help me with the answer for this ( how can I customized to write the log file to a specific directory) ?

  • Chetan Link Reply

    How can we create .log files daily basis ?

  • Sean Link Reply

    Why write your own methods here when they are provided…

    you created a class for these methods

    public static void Error(string message, string module)
    public static void Error(Exception ex, string module)
    public static void Warning(string message, string module)
    public static void Info(string message, string module)

    When you could just use…

    Trace.TraceInformation(string message)
    Trace.TraceWarning(string message)
    Trace.TraceError(string message)

    this also means you would not have to include the class you wrote.

    • Hi Sean – thanks for your comments. When I wrote this article I wasn’t aware of the built in .NET methods you mentioned and that’s why I wrote my own. I should probably update my article to mention this – thanks for pointing that out.

  • Bud Link Reply

    One little fact I don’t see mentioned in the article, where does the ‘application.log’ reside?

    • Hi Bud – the log is written where you specify in the App.config file, however in this example it’s in the directory where the application is running from (the bin folder).

  • xarkam Link Reply

    Hello,

    it’s possible to have one log file per day ?

  • Jay Link Reply

    Thank you! it was very useful 🙂

  • ILORA CHATTERJEE Link Reply

    Thnx a lot.it is realy helpful 🙂

  • Vidhya Link Reply

    I could not find the application.log

  • Krishna Prasad Link Reply

    Hi Dave,

    Thank you so much for such a good article.
    Really it made easy for my development.

    Congrats!

  • Nice post thanks

  • Jyoti Link Reply

    Hi Dave,

    Very nice article. You explained the TraceListener in a very easy mode.
    Fresher, Intermediate and advanced level people can learn this topic very easily.

    Good Work. Keep it up.

  • John Link Reply

    Nice example. Something it does not mention is how these log files rolling out. What need to do in app configuration to make file rolling happen.

    Do you have exmaple?

  • Request: Please , update example to include, wrap the log file after it grows to 5MB, Use of the built in class per Sean’s comments “(Trace.TraceInformation(string message)”.

    Otherwise , this is a fantastic explanation. I couldn’t wrap my brain around logging till I saw this example.

    Thanks!

  • harsh Link Reply

    hi,

    Its very useful and to the point. but I have a one question. In my application I want to use two listeners. and on the basis of condition I want to log data in specific file.

    is this possible? if yes then how? your reply is highly appriciated…:)

  • diksha Link Reply

    Hi,
    In this file path is static but i need to change filename every time.
    Log messages going to previously created log file but i want always it has changed accordingly date.
    such as
    aplication20-05-2015.log
    aplication21-05-2015.log

    PLease help

  • Subbu Link Reply

    Nice article Dave! Precise and Concise…Thanks a lot!

  • Marianne Link Reply

    Awesome! It worked perfectly!

  • Ashwathi Link Reply

    That was pretty simple and straightforward. Thank you!!

  • avi Link Reply

    hi dave thanx for the post 🙂 its will work also in server like web apps or cloud service of azure ? thanx again:)

  • Ivan Link Reply

    Hi, I found this very helpful, thank you. I have a question though, is it possible to make a different log daily based on the date? Say 2016_12_06.log

    I guess it would be right here: initializeData=DateTime.Now.ToShortDateString()+ “.log”
    Of course I don’t know where to get the Date part from. I would appreciate any help.

  • Steve Smith Link Reply

    Really helpful.

  • Mary Clemons Link Reply

    Do you have any recommendations for developers writing c# applications for heavily utilized commercial products? Error logging for high volumes needs to scale significantly when it leaves the developer’s desk. Even QA might not have the environment to realistically simulate production or even real world test environment loads.

    • Whenever I had a system generating a large amount of log entries I’d log them to the database instead of to a text file. And obviously I’d have a check in there to log to a text file if unable to acces the database. Another option would be to log to text files and roll them over on a daily basis, or even hourly basis if required. And then to not end up with thousands of log files on disk I’d archive them either by compressing or by moving them elsewhere, or even just purging after a certain date.

  • Mojtaba Rahmani Link Reply

    it’s very very useful, thank you very much.

Leave a Comment