© 2011 By: Dov Trietsch. All rights reserved
Logging – A log blog
In a another blog (Missing Fields and Defaults) I spoke about not doing a blog about log files, but then I looked at it again and realized that this is a nice opportunity
to show a simple yet powerful tool and also deal with static variables and functions in C#.
My log had
to be able
to answer a few simple logging rules:
To log or not
to log? That is the question – Always log! That is the answer
Do we share a log? Even when a file is opened with a minimal lock, it does not share well and performance greatly suffers. So sharing a log is not a good idea. Also, when sharing, it is harder
to find your particular entries and you have
to establish rules about retention. My recommendation – Do Not Share!
How verbose? Your log can be very verbose – a good thing when testing, very terse – a good thing in day-to-day runs, or somewhere in between. You must be the judge. In my Blog, I elect
to always report a run with start and end times, and always report errors. I normally use 5 levels of logging: 4 – write all, 3 – write more, 2 – write some, 1 – write errors and timing, 0 – write none. The code sample below is more general than that. It uses the config file
to set the max log level and each call
to the log assigns a level
to the call itself. If the level is above the .config highest level, the line will not be written. Programmers decide which log belongs
to which level and thus we can set the .config differently for production and testing.
Where do I keep the log? If your career is important
to you, discuss this with the boss and with the system admin. We keep logs in the L: drive of our server and make sure that we have a directory for each app that needs a log. When adding a new app, add a new directory. The default location for the log is also found in the .config file
Print One or Many? There are two options here:
1. Print many, Open but once once – you start the stream and close it only when the program ends. This is what you can do when you perform in “batch” mode like in a console app or a stsadm extension.The advantage
to this is that starting a closing a stream is expensive and time consuming and because we use a unique file, keeping it open for a long time does not cause contention problems.
2. Print one entry at a time or Open many – every time you write a line, you start the stream, write
to it and close it. This work for event receivers, feature receivers, and web parts. Here scalability requires us
to create
objects on the fly and get rid of them as soon as possible.
A default value of the onceOrMany resides in the .config.
All of the above applies
to any windows or web application, not just SharePoint.
So as usual, here is a routine that does it all, and a few simple functions that call it for a variety of purposes.
So without further ado, here is app.config
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<sectionGroup name="applicationSettings"
type="System.Configuration.ApplicationSettingsGroup, System, Version=2.0.0.0, Culture=neutral,
ublicKeyToken=b77a5c561934e089" >
<section name="statics.Properties.Settings"
type="System.Configuration.ClientSettingsSection, System, Version=2.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089" requirePermission="false" />
</sectionGroup>
</configSections>
<applicationSettings>
<statics.Properties.Settings>
<setting name="oneOrMany" serializeAs="String">
<value>False</value>
</setting>
<setting name="logURI" serializeAs="String">
<value>C:\staticLog.txt</value>
</setting>
<setting name="highestLevel" serializeAs="String">
<value>2</value>
</setting>
</statics.Properties.Settings>
</applicationSettings>
</configuration>
And now the code:
In order
to persist the variables between calls and also
to be able
to persist (or not
to persist) the log file itself, I created an EventLog class with static variables and functions. Static functions do not need an instance of the class in order
to work. If you ever wondered why our Main function is static, the answer is that something needs
to run before instantiation so that other
objects may be instantiated, and this is what the “static” Main does. The various logging functions and variables are created as static because they do not need instantiation and as a fringe benefit they remain un-destroyed between calls.
The Main function here is just used for testing. Note that it does not instantiate anything, just uses the log functions. This is possible because the functions are static. Also note that the function calls are of the form: Class.Function.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace statics
{
class Program
{
static void Main(string[] args)
{
//write a single line
EventLog.LogEvents("ha ha", 3, "C:\\hahafile.txt", 4, true, false);
//this single line will not be written because the msgLevel is too high
EventLog.LogEvents("baba", 3, "C:\\babafile.txt", 2, true, false);
//The next 4 lines will be written in succession - no closing
EventLog.LogLine("blah blah", 1);
EventLog.LogLine("da da", 1);
EventLog.LogLine("ma ma", 1);
EventLog.LogLine("lah lah", 1);
EventLog.CloseLog(); // log will close
//now with specific functions
EventLog.LogSingleLine("one line", 1);
//this is just a test, the log is already closed
EventLog.CloseLog();
}
}
public class EventLog
{
public static string logURI = Properties.Settings.Default.logURI;
public static bool isOneLine = Properties.Settings.Default.oneOrMany;
public static bool isOpen = false;
public static int highestLevel = Properties.Settings.Default.highestLevel;
public static StreamWriter sw;
/// <summary>
/// the program will "print" the msg into the log
/// unless msgLevel is > msgLimit
/// onceOrMany is true when once - the program will open the log
/// print the msg and close the log. False when many the program will
/// keep the log open until close = true
/// normally all the arguments will come from the app.config
/// called by many overloads of logLine
/// </summary>
/// <param name="msg"></param>
/// <param name="msgLevel"></param>
/// <param name="logFileName"></param>
/// <param name="msgLimit"></param>
/// <param name="onceOrMany"></param>
/// <param name="close"></param>
public static void LogEvents(string msg, int msgLevel, string logFileName, int msgLimit, bool oneOrMany, bool close)
{
//to print or not
to print
if (msgLevel <= msgLimit)
{
//open the file. from the argument (logFileName) or from the config (logURI)
if (!isOpen)
{
string logFile = logFileName;
if (logFileName == "")
{
logFile = logURI;
}
sw = new StreamWriter(logFile, true);
sw.WriteLine("Started At: " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
isOpen = true;
}
//print
sw.WriteLine(msg);
}
//close when instructed
if (close || oneOrMany)
{
if (isOpen)
{
sw.WriteLine("Ended At: " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
sw.Close();
isOpen = false;
}
}
}
/// <summary>
/// The simplest, just msg and level
/// </summary>
/// <param name="msg"></param>
/// <param name="msgLevel"></param>
public static void LogLine(string msg, int msgLevel)
{
//use the given msg and msgLevel and all others are defaults
LogEvents(msg, msgLevel, "", highestLevel, isOneLine, false);
}
/// <summary>
/// one line at a time - open print close
/// </summary>
/// <param name="msg"></param>
/// <param name="msgLevel"></param>
public static void LogSingleLine(string msg, int msgLevel)
{
LogEvents(msg, msgLevel, "", highestLevel, true, true);
}
/// <summary>
/// used
to close. high level, low limit, once and close are set
/// </summary>
/// <param name="close"></param>
public static void CloseLog()
{
LogEvents("", 15, "", 1, true, true);
}
}
}
}
That’s all folks!
