Click here to Skip to main content
14,392,692 members

Simple Log

Rate this:
4.94 (29 votes)
Please Sign up or sign in to vote.
4.94 (29 votes)
18 Jun 2016MIT
Essential logging in one simple, robust, static, thread-safe class. No initialization, no configuration, no dependencies. Don't think, just log.

SimpleLog demo usage


A simple but robust logging class that fulfills the following requirements:

  • One simple, static class, easy to understand.
  • Works "out of the box", just include it and start logging. No initialization, no configuration necessary. No dependencies.
  • Simple, static methods to write a log entry.
  • Logs XML fragments or plain text to a file, one tag or one line per log entry.
  • Easy but flexible way to change file and folder where logs are written to.
  • Possibility to pass log severity (info, warning, error, exception).
  • Possibility of simple filtering by log severity.
  • Log exceptions recursively with all inner exceptions, data, stack trace and specific properties of some exception types.
  • Has very little impact on performance of the main program due to queue-and-background task approach.
  • Is thread-safe, i.e., several threads can log into the same file concurrently.
  • Automatically logs the class and method name where the log method was called from.
  • Exceptions occurring when writing to the log file, e.g. due to insufficient rights, get logged to event log, including log file name and current process user name. Log source is "SimpleLog".
  • Robust, compact and well-documented.


Some time ago, I was looking for a really simple logging class.

Having a small project with a handful of files and classes, I didn't want to blow it up with a complex framework like log4net with dozens of classes and files. I didn't want to deal with hundreds of options and configuration settings. I didn't want to add a configuration file, just for logging. I didn't want to spend hours learning how logging works with a particular framework.

I just wanted to include one class as source code and start logging. A class I can understand in minutes, not days, and I can eventually extend to my needs. Simple as that. I thought "why re-invent the wheel?" there are millions of logging approaches out there!

I stumbled over Marco Manso's Really Simple Log Writer. Yeah, that is really simple! A static class with some logging methods, working "out of the box". Logs XML fragments to a file, one tag per entry. Just what I was looking for!

Well ... logging inner exceptions should be done recursively. No big deal, changed in a minute. Oh, there is some code-redundancy in writing the logs ... no problem, duplicate code extracted in a separate method. Hmm, configuring the log file name and its location could be done in a more consistent, flexible way ... and comments and regions would be a good idea, too. When I'm logging, I'd like to distinguish between info, warning and error. That's really not asking for too much, is it? Ok, logging severity built in, along with some shortcut methods, of course. For compactness, IMHO, severity, date and time, should not be logged as separate tags, but as attributes - changed. One thing that I ever wanted and often missed, is that the location in code where a logging method was called is logged automatically. This way, you do not have to write "exception in method xy ..." each time; logging does that for you! Built in quickly. What do people suggest for Marco's class? A method to get the log file completed to a regular XML document? Right, that will be needed for sure. And when we're already about it, it could be shown in the browser with just one call. Great, isn't it? Log filtering is something that is always available in every logging system. Shall this class provide it, too? Yes, but it must be very basic and intuitive. Should not have an impact on the learning curve - built in a simple filtering by severity that everyone will understand instantly. Whew, we're through now, aren't we? What about performance and thread safety? True. We're neither - nor. Good logging systems have a queue and a background task to actually write the entries to disk. That way, they achieve both, performance and thread safety. Hmm, wasn't I looking for a simple class initially? That feature would make the class much (?) more complex. But it's the correct way how to do it! It's the last thing I'm adding.

Now, the class can be used in any project without worrying - and it is still comparably simple and easy to understand. From my point of view, it should be a good compromise between simplicity and functionality.

Using the Code

As Marco nicely expressed it: That's the beauty of it. Just include the class as source code anywhere in your project and start logging:

// Write info message to log
SimpleLog.Info("Test logging started.");

// Write warning message to log
SimpleLog.Warning("This is a warning.");

// Write error message to log
SimpleLog.Error("This is an error.");

That will produce the following output in a log file e.g. "2013_04_29.log" in the current working directory:

<LogEntry Date="2013-04-29 18:56:43" Severity="Info" 

              Source="SimpleLogDemo.Program.Main" ThreadId="9">
  <Message>Test logging started.</Message>
<LogEntry Date="2013-04-29 18:56:43" Severity="Warning" 

               Source="SimpleLogDemo.Program.Main" ThreadId="9">
  <Message>This is a warning.</Message>
<LogEntry Date="2013-04-29 18:56:43" Severity="Warning" 

               Source="SimpleLogDemo.Program.Main" ThreadId="9">
  <Message>This is an error.</Message>

Of course, exceptions can be logged, too, including all inner exceptions:

    // For demonstration, do logging in sub-method, 
    // throw an exception, catch it, wrap it in 
    // another exception and throw it.
catch(Exception ex)
    // Write exception with all inner exceptions to log


/// <summary>
/// Do something for demonstration
/// </summary>
private static void DoSomething()
    SimpleLog.Info("Entering method. See Source which method is meant.");

    catch(Exception ex)
        throw new InvalidOperationException("Something went wrong.", ex);

/// <summary>
/// Do something else for demonstration
/// </summary>
/// <remarks>
/// Purposely provoke an exception
/// </remarks>
/// <param name="fred">Should not be null</param>
private static void DoSomethingElse(string fred)
    SimpleLog.Info("Entering method. See Source which method is meant.");

        // Purposely provoking an exception.
        int a = fred.IndexOf("Hello");
    catch(Exception ex)
        throw new Exception("Something went wrong.", ex);

That will produce the following output:

<LogEntry Date="2013-04-29 18:56:43" Severity="Info" 

                 Source="SimpleLogDemo.Program.DoSomething" ThreadId="9">
  <Message>Entering method. See Source which method is meant.</Message>
<LogEntry Date="2013-04-29 18:56:43" Severity="Info" 

           Source="SimpleLogDemo.Program.DoSomethingElse" ThreadId="9">
  <Message>Entering method. See Source which method is meant.</Message>
<LogEntry Date="2013-04-29 18:56:43" Severity="Exception" 

             Source="SimpleLogDemo.Program.Main" ThreadId="9">
  <Exception Type="System.InvalidOperationException" 

    <Message>Something went wrong.</Message>
    <Exception Type="System.Exception" 

      <Message>Something went wrong.</Message>
      <Exception Type="System.NullReferenceException" 

        <Message>Object reference not set to an instance of an object.</Message>
        <StackTrace>   at SimpleLogDemo.Program.DoSomethingElse(String fred) 
           in D:\Projekt\VisualStudio\SimpleLogDemo\SimpleLogDemo\Program.cs:line 91</StackTrace>

The log file that is written to is assembled as follows:

/// <summary>
/// File to log in
/// </summary>
/// <remarks>
/// Is assembled from <see cref="LogDir"/>, <see cref="Prefix"/>, the current date and 
/// time formatted in <see cref="DateFormat"/>,
/// <see cref="Suffix"/>, "." and <see cref="Extension"/>. 
/// So, by default, the file is named e.g. "2013_04_21.log" and is written to the current 
/// working directory.
/// It is assembled in <see cref="GetFileName"/> using <code>string.Format("{0}\\{1}{2}{3}.{4}", 
/// LogDir, Prefix, dateTime.ToString(DateFormat), Suffix, Extension)</code>.
/// </remarks>
public static string FileName
        return GetFileName(DateTime.Now);

/// <summary>
/// Gets the log filename for the passed date
/// </summary>
/// <param name="dateTime">The date to get the log file name for</param>
/// <returns>The log filename for the passed date</returns>
public static string GetFileName(DateTime dateTime)
    return string.Format("{0}\\{1}{2}{3}.{4}", LogDir, Prefix, 
                         dateTime.ToString(DateFormat), Suffix, Extension);

Want to use another log file at another location? Apart from setting several properties like prefix, suffix, extension, directory, log level, etc. separately, you can use convenience method SetLogFile to set them all at once:

/// <summary>
/// Set all log properties at once
/// </summary>
/// <remarks>
/// Set all log customizing properties at once. This is a pure convenience function. 
/// All parameters are optional.
/// When <see cref="logDir"/> is set and it cannot be created or writing a first entry fails, 
/// no exception is thrown, but the previous directory,
/// respectively the default directory (the current working directory), is used instead.
/// </remarks>
/// <param name="logDir"><see cref="LogDir"/> 
/// for details. When null is passed here, 
/// <see cref="LogDir"/> is not set. 
/// Here, <see cref="LogDir"/> is created, when it does not exist.</param>
/// <param name="prefix"><see cref="Prefix"/> for details. 
/// When null is passed here, <see cref="Prefix"/> is not set.</param>
/// <param name="suffix"><see cref="Suffix"/> for details. 
/// When null is passed here, <see cref="Suffix"/> is not set.</param>
/// <param name="extension"><see cref="Extension"/> for details. 
/// When null is passed here, <see cref="Extension"/> is not set.</param>
/// <param name="dateFormat"><see cref="DateFormat"/> for details. 
/// When null is passed here, <see cref="DateFormat"/> is not set.</param>
/// <param name="logLevel"><see cref="LogLevel"/> for details. 
/// When null is passed here, <see cref="LogLevel"/> is not set.</param>
/// <param name="startExplicitly"><see cref="StartExplicitly"/> for details. 
/// When null is passed here, <see cref="StartExplicitly"/> is not set.</param>
/// <param name="check">Whether to call <see cref="Check"/>, 
/// i.e. whether to write a test entry after setting the new log file. 
/// If true, the result of <see cref="Check"/> is returned.</param>
/// <param name="writeText"><see cref="WriteText"/> for details. 
/// When null is passed here, <see cref="WriteText"/> is not set.</param>
/// <param name="textSeparator"><see cref="TextSeparator"/> for details. 
/// When null is passed here, <see cref="TextSeparator"/> is not set.</param>
/// <returns>Null on success, otherwise an exception with what went wrong.</returns>
public static Exception SetLogFile(string logDir = null, string prefix = null, string suffix = null, 
string extension = null, string dateFormat = null, Severity? logLevel = null, 
bool? startExplicitly = null, bool check = true, bool? writeText = null, 
string textSeparator = null)

For example, you can say:

// Log to a sub-directory 'Log' of the current working directory.
// Prefix log file with 'MyLog_'.
// Write XML file, not plain text.
// This is an optional call and has only to be done once,
// preferably before the first log entry is written.
SimpleLog.SetLogFile(logDir: ".\\Log", prefix: "MyLog_", writeText: false);

Note: In contrast to logging itself, changing log file settings, i.e., changing the file it is written to, is NOT thread-safe. It won't crash, though, but unwanted results may occur. It is not intended to change log file settings during regular logging, but once at application startup (before the first log entry is written) and then left alone.

To get a log file as complete XML, you can use:

/// <summary>
/// Get the log file for the passed date as XML document
/// </summary>
/// <remarks>
/// Does not throw an exception when the log file does not exist.
/// </remarks>
/// <param name="dateTime">The date and time to get the log file for. 
/// Use DateTime.Now to get the current log file.</param>
/// <returns>The log file as XML document or null when it does not exist.</returns>
public static XDocument GetLogFileAsXml(DateTime dateTime)

You can also show the current log file in the related application (e.g. a browser or a text editor) with just one line:

/// <summary>
/// Shows the current log file
/// </summary>
/// <remarks>
/// Opens the default program to show text or XML files and displays 
/// the requested file, if it exists. Does nothing otherwise.
/// When <see cref="WriteText"/> is false, a temporary XML file 
/// is created and saved in the users's temporary path each time this method is called.
/// So don't use it excessively in that case. Otherwise, the log file itself is shown.
/// </remarks>
public static void ShowLogFile()

That's it! You don't have to care about anything else. Enjoy!


  • 29th April, 2013 - First published, Version 1.0
  • 19th June, 2014 - Added possibility to log directly to disk, without background task, Version 1.1
  • 19th June, 2014 - Added possibility to start background task explicitly
  • 07th December, 2014 - Corrected typo and added stub for writing text instead of XML, Version 1.1.1
  • 08th December, 2014 - Basic implementation of writing text instead of XML, Version 1.2
  • 18th June, 2016 - Fixed bug that avoided that last remaining log entries get logged, Version 1.2.1
  • 16th July, 2016 - Fixed bug when transforming exception data to XML attributes, Version 1.2.2
  • 16th July, 2016 - Write exceptions occurring when writing to the log file to event log, Version 1.2.2


This article, along with any associated source code and files, is licensed under The MIT License


About the Author

Jochen Scharr
Software Developer (Senior)
Germany Germany
No Biography provided

Comments and Discussions

QuestionHow do I get the current log file name? Pin
Andrew Truckle14-Jun-19 1:17
professionalAndrew Truckle14-Jun-19 1:17 
BugException when logging Exception (with no TargetSite or Source) Pin
smcSoon20-Apr-19 10:27
MembersmcSoon20-Apr-19 10:27 
PraiseGreat work thank you Pin
smcSoon8-Apr-19 23:11
MembersmcSoon8-Apr-19 23:11 
QuestionOutOfMemoryException Pin
Joey Spruill20-Apr-18 5:11
MemberJoey Spruill20-Apr-18 5:11 
QuestionFix for code analysis Pin
Andrew Truckle17-Sep-17 5:40
professionalAndrew Truckle17-Sep-17 5:40 
QuestionLogging to the program files folder Pin
Andrew Truckle12-Sep-17 5:56
professionalAndrew Truckle12-Sep-17 5:56 
QuestionSpecify maximum file size Pin
hairy_hats16-Aug-17 2:16
Memberhairy_hats16-Aug-17 2:16 
QuestionJust what I was looking for. Pin
jduford26-May-17 6:28
Memberjduford26-May-17 6:28 
Questionreally usefull Pin
Arthur Arapetian16-Apr-17 13:12
MemberArthur Arapetian16-Apr-17 13:12 
QuestionWhat about making the log file unicode rather than ansi? Pin
Andrew Truckle7-Feb-17 6:47
MemberAndrew Truckle7-Feb-17 6:47 
QuestionSome sugerences Pin
marcelo.nicolet24-Jan-17 9:40
Membermarcelo.nicolet24-Jan-17 9:40 
QuestionAny Concerns Using SimpleLog in a WebForms ASPX Website? Pin
MacroDaveW20-Dec-16 6:56
MemberMacroDaveW20-Dec-16 6:56 
AnswerRe: Any Concerns Using SimpleLog in a WebForms ASPX Website? Pin
Jochen Scharr20-Dec-16 14:24
MemberJochen Scharr20-Dec-16 14:24 
Questionreal simple and useful Pin
Member 1005886926-Oct-16 3:24
MemberMember 1005886926-Oct-16 3:24 
QuestionIs it available on nuget? Pin
Dylan Hyslop7-Oct-16 0:38
MemberDylan Hyslop7-Oct-16 0:38 
QuestionCan Simple Log be used in a Windows Service? Pin
MacroDaveW13-Jul-16 15:09
MemberMacroDaveW13-Jul-16 15:09 
AnswerRe: Can Simple Log be used in a Windows Service? Pin
Jochen Scharr13-Jul-16 23:41
MemberJochen Scharr13-Jul-16 23:41 
AnswerRe: Can Simple Log be used in a Windows Service? Pin
Jochen Scharr16-Jul-16 8:00
MemberJochen Scharr16-Jul-16 8:00 
Question[Bugfix] If Excepetion.Data IDicitionary Value == null Pin
AirLancer4-Jul-16 11:01
MemberAirLancer4-Jul-16 11:01 
AnswerRe: [Bugfix] If Excepetion.Data IDicitionary Value == null Pin
Jochen Scharr14-Jul-16 0:04
MemberJochen Scharr14-Jul-16 0:04 
AnswerRe: [Bugfix] If Excepetion.Data IDicitionary Value == null Pin
Jochen Scharr16-Jul-16 8:02
MemberJochen Scharr16-Jul-16 8:02 
QuestionStopLogging & Flush Pin
Member 1233706716-Jun-16 11:15
MemberMember 1233706716-Jun-16 11:15 
AnswerRe: StopLogging & Flush Pin
Jochen Scharr18-Jun-16 3:41
MemberJochen Scharr18-Jun-16 3:41 
QuestionThanks Jochen! Pin
Tim Tatum22-Feb-16 8:09
MemberTim Tatum22-Feb-16 8:09 
QuestionQuestion Pin
Member 1206160021-Oct-15 8:49
MemberMember 1206160021-Oct-15 8:49 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Posted 30 Apr 2013


60 bookmarked