Implementing Rolling log file in ASP.NET and EntLib 5.0

Question

I am using EntLib 5 to create rolling flat file. This does not use the Rolling Flat File trace listener but the Flat File Trace listener with some modifications in the code. Rolling Flat File trace listener was not used becuase of issues with it's inherent design as such does not fit the requirement here.

Here is the configuration section:

    <configuration>
    <configSections>
        <section name="loggingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.LoggingSettings, Microsoft.Practices.EnterpriseLibrary.Logging, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true"/>
        <sectionGroup name="system.web.extensions" type="System.Web.Configuration.SystemWebExtensionsSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
            <sectionGroup name="scripting" type="System.Web.Configuration.ScriptingSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
                <section name="scriptResourceHandler" type="System.Web.Configuration.ScriptingScriptResourceHandlerSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>
                <sectionGroup name="webServices" type="System.Web.Configuration.ScriptingWebServicesSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
                    <section name="jsonSerialization" type="System.Web.Configuration.ScriptingJsonSerializationSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="Everywhere"/>
                    <section name="profileService" type="System.Web.Configuration.ScriptingProfileServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>
                    <section name="authenticationService" type="System.Web.Configuration.ScriptingAuthenticationServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>
                    <section name="roleService" type="System.Web.Configuration.ScriptingRoleServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>
                </sectionGroup>
            </sectionGroup>
        </sectionGroup>
    </configSections>
    <loggingConfiguration name="" tracingEnabled="true" defaultCategory="General">
  <listeners>
   <add name="Flat File Trace Listener" type="Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners.FlatFileTraceListener, Microsoft.Practices.EnterpriseLibrary.Logging, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
    listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.FlatFileTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
    fileName="./Logs/MyLog.log" formatter="Text Formatter" />
  </listeners>
  <formatters>
   <add type="Microsoft.Practices.EnterpriseLibrary.Logging.Formatters.TextFormatter, Microsoft.Practices.EnterpriseLibrary.Logging, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
    template="Timestamp: {timestamp(local)}{newline}&#xA;Message: {message}{newline}&#xA;Category: {category}{newline}&#xA;Priority: {priority}{newline}&#xA;EventId: {eventid}{newline}&#xA;Severity: {severity}{newline}&#xA;Title:{title}{newline}&#xA;Machine: {localMachine}{newline}&#xA;App Domain: {localAppDomain}{newline}&#xA;ProcessId: {localProcessId}{newline}&#xA;Process Name: {localProcessName}{newline}&#xA;Thread Name: {threadName}{newline}&#xA;Win32 ThreadId:{win32ThreadId}{newline}&#xA;Extended Properties: {dictionary({key} - {value}{newline})}"
    name="Text Formatter" />
  </formatters>
  <categorySources>
   <add switchValue="All" name="General">
    <listeners>
     <add name="Flat File Trace Listener" />
    </listeners>
   </add>
  </categorySources>
  <specialSources>
   <allEvents switchValue="All" name="All Events" />
   <notProcessed switchValue="All" name="Unprocessed Category" />
   <errors switchValue="All" name="Logging Errors &amp; Warnings">
    <listeners>
     <add name="Flat File Trace Listener" />
    </listeners>
   </errors>
  </specialSources>
 </loggingConfiguration>
    <appSettings>
        <add key="LogFolder" value="./Logs"/>
        <add key="LogFileName" value="MyLog.log"/>
    </appSettings>
    <system.web>

Then I create a static class with the following code to configure the logging process:

public static class LoggingHelper {
private static string date = String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0:yyyyMMdd}", DateTime.Now);

public static void SetLogFile(string logFileFolder,string logFileName) {
    if (!string.IsNullOrEmpty(logFileName)) {
        string strfileName = logFileFolder + "/" + date + logFileName;
        LoggingHelper.SetTraceLogPath(strfileName, "FlatFile TraceListener", "General", "My Login System");
        LoggingHelper.WriteLogFile("General", "Log file path " + logFileFolder + "/" + logFileName, " My Login System");
    }
}  

public static void SetTraceLogPath(string logFile, string logFileName, string category, string message) {
    ConfigurationFileMap configFileMap = new ConfigurationFileMap();
    configFileMap.MachineConfigFilename = "Web.config";
    Configuration entLibConfig = WebConfigurationManager.OpenWebConfiguration("/ASP.NET_Logging");
    LoggingSettings loggingSettings = (LoggingSettings)entLibConfig.GetSection(LoggingSettings.SectionName);

    FlatFileTraceListenerData data = loggingSettings.TraceListeners.Get("Flat File Trace Listener") as FlatFileTraceListenerData;
    data.FileName = logFile;
    entLibConfig.Save();
    LogEntry objLog = new LogEntry();
    objLog.TimeStamp = System.DateTime.Now;
    objLog.Categories.Add(category);
    objLog.Message = message;
    objLog.Priority = 1;
    Logger.Write(objLog);

}

public static void WriteLogFile(string category, string msg, string title) {
    try {
        LogEntry le = new LogEntry();
        le.TimeStamp = System.DateTime.Now;
        le.Categories.Add(category);
        le.Severity = TraceEventType.Information;
        le.Priority = 1;
        le.Message = msg;
        le.Title = title;
        le.Priority = 1;
        Logger.Write(le);
    } catch (LoggingException ex) {
        LoggingHelper.WriteLogFile("General", "Error in writing log file " + ex.ToString(), "My Login System");
    }
}}

The SetLogFile is called in the Application_Start method is Global.aspx page like so:

void Application_Start(object sender, EventArgs e) 
{
    // Code that runs on application startup
    LoggingHelper.SetLogFile(ConfigurationSettings.AppSettings["LogFolder"].Trim     (),      ConfigurationSettings.AppSettings["LogFileName"].Trim());
    LoggingHelper.WriteLogFile("General", "*** Application_Start ***", "");
}

Then I just call the WriteLogFile method wherever logging is required like so:

protected void btn_Page2_Click(object sender, EventArgs e) {
    LoggingHelper.WriteLogFile("General", "btn_Page2_Click on Default.aspx", "");

    Response.Redirect("SecongPage.aspx");

}

This works fine but for a minor issue. When the webpage is accessed for the first time it does not create the log file with Logfilename.log format, it just creates MyLog.log or whatever name is specified in Web.config and the log file is created outside the specified folder, in this case 'Log', for the first time. For consequent requests it will create the desired file with the desired filename in the configured folder. This pattern is repeated on daily basis, the next day for the first request, the log will be written in yesterday's file and from the next request onwards a new file with today's date is created and all the log messages will be written in that file.

What did I do in my code which is causing this to happen?

We use the above code, with minor changes, for logging in our WinForms applications with no issues.

The website is currently not deployed at IIS. Since it's a work in progress, we are using the built-in development server from VS 2008. Another casue of concern is that the code tries to update the Web.config, at leat once, during startup. Don't know if this is the way to go about it!

This is a very simple sample with two pages, the first page has a button when clicked directs to second page. I am trying to have log file implemented on daily basis and the Rolling Flat File that comes with EntLib does not fit the requirement as it will not create a file on daily basis with the required date for that day.

Regards.

Answer 1

after searching for a long time. This is what I came up with. The idea is to use a FlatFile Trace listner instead of the in-build Rolling Flat File.

Disclaimer: One of my colleagues had this code with him, he does not remember from where he got it, so if you are the owner or have written code similar to this, then thanks to you.

Please don't vote for this answer as I am not the owner of it. Nevertheless it's here to help anyone looking for similar implementation

This uses EntLib 4, but can be used with EntLib 5 as well.

Here is the logging part from my Web.config:

<loggingConfiguration name="Logging Application Block" tracingEnabled="true"
defaultCategory="User" logWarningsWhenNoCategoriesMatch="true">
<listeners>
  <add fileName="trace.log" header="----------------------------------------"
    footer="----------------------------------------" formatter=""
    listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.FlatFileTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
    traceOutputOptions="None" filter="All" type="Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners.FlatFileTraceListener, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
    name="FlatFile TraceListener" />
  <add fileName="MyLoggingSystem.log" header="" footer="" formatter="Text Formatter"
    listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.FlatFileTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
    traceOutputOptions="None" filter="All" type="Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners.FlatFileTraceListener, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
    name="MyLoggingApp FlatFile TraceListener " />
  <add listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.WmiTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
    traceOutputOptions="None" filter="All" type="Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners.WmiTraceListener, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
    name="WMI TraceListener" />
</listeners>
<formatters>
  <add template="[{timestamp}]  [{category}] {message}" type="Microsoft.Practices.EnterpriseLibrary.Logging.Formatters.TextFormatter, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
    name="Text Formatter" />
</formatters>
<categorySources>
  <add switchValue="All" name="Developer">
    <listeners>
      <add name="FlatFile TraceListener" />
    </listeners>
  </add>
  <add switchValue="All" name="General" />
  <add switchValue="All" name="Instrumentation">
    <listeners>
      <add name="WMI TraceListener" />
    </listeners>
  </add>
  <add switchValue="All" name="EskoLoggingApp">
    <listeners>
      <add name="MyLogging FlatFile TraceListener " />
    </listeners>
  </add>
  <add switchValue="All" name="User">
    <listeners>
      <add name="FlatFile TraceListener" />
    </listeners>
  </add>
</categorySources>
<specialSources>
  <allEvents switchValue="All" name="All Events" />
  <notProcessed switchValue="All" name="Unprocessed Category" />
  <errors switchValue="All" name="Logging Errors &amp; Warnings">
    <listeners>
      <add name="FlatFile TraceListener" />
    </listeners>
  </errors>
</specialSources>
</loggingConfiguration>

I have two more sections, file name and folder to save the file:

<appSettings>
    <add key="LogFolder" value="./Logs" />
    <add key="LogFileName" value="MyLoginSystem" />
</appSettings>

Create a class like so:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Configuration;
using Microsoft.Practices.EnterpriseLibrary.Logging.Configuration;
using Microsoft.Practices.EnterpriseLibrary.Logging;
using System.Diagnostics;
using System.Globalization;
using Microsoft.Practices.EnterpriseLibrary.Logging.Formatters;
using Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners;
using Microsoft.Practices.EnterpriseLibrary.Logging.Filters;

/// <summary>
/// Summary description for Utility
/// </summary>
public static class Utility {
    /// <summary>
    /// Instance for log writer 
    /// </summary> 
    private static LogWriter writer;

    /// <summary>
    /// Instance for log writer 
    /// </summary> 
    private static LogWriter wmiWriter;

    /// <summary>
    /// Instance for log writer 
    /// </summary> 
    private static LogWriter eskoLoggingWriter;

    /// <summary>
    /// Intialize the Trace listners without using app.config file
    /// </summary>
    /// <param name="fileName">log file name</param>
    public static void Initialize(string fileName) {
        CreateLogWriterFromCode(fileName);
    }


    /// <summary>
    /// Log User Messages
    /// </summary>
    /// <param name="message">Message text</param>
    /// <param name="prior">Logger Priority</param>
    /// <param name="traceType">Trave event type</param>
    public static void LogUserMessage(string message, int prior, System.Diagnostics.TraceEventType traceType) {
        LogEntry(message, "User", prior, traceType);
    }

    /// <summary>
    /// Any type of Log Entry 
    /// </summary>
    /// <param name="message">Message text</param>
    /// <param name="category">Logger category</param>
    /// <param name="prior">Priory logger </param>
    /// <param name="traceType">Trace event type</param>
    public static void LogEntry(string message, string category, int prior, System.Diagnostics.TraceEventType traceType) {
        try {
            LogEntry log = null;
            log = new LogEntry();
            log.Message = message;
            log.Categories.Add(category);
            log.Severity = traceType;
            log.Priority = prior;
            log.TimeStamp = DateTime.Now;
            if (writer != null) {
                writer.Write(log);
            } else {
                eskoLoggingWriter.Write(log);
            }
            // wmiWriter.Write(log);
        } catch (LoggingException ex) {
            LogEntry(ex.Message, "Developer", prior, traceType);
        }
    }

    /// <summary>
    /// Log Developer Messages 
    /// </summary>
    /// <param name="message">Message text</param>
    /// <param name="prior">Logger priority</param>
    /// <param name="traceType">Trace event type</param>
    public static void LogDeveloperMessage(string message, int prior, System.Diagnostics.TraceEventType traceType) {
        LogEntry(message, "Developer", prior, traceType);
    }

    /// <summary>
    /// Close splash screen
    /// </summary>
    public static void ExitSplash() {
        Logger.Reset();
    }

    /// <summary>
    /// Disposing log write instance
    /// </summary>
    public static void Dispose() {
        if (writer != null) {
            writer = null;
        }
    }

    /// <summary>
    /// Creating log writer programatically 
    /// </summary>
    /// <param name="fileName">Full path of log file</param>
    static private void CreateLogWriterFromCode(string fileName) {
        if (writer != null) {
            writer = null;
        }
        //// The formatter is responsible for the look of the message. Notice the tokens: {timestamp}, {newline}, {message}, {category}
        TextFormatter formatter = new TextFormatter
            ("[{timestamp}]" + "[{category}]" + "{message}{newline}");

        //// Log messages to a log file. Use the formatter mentioned above specified.

        FlatFileTraceListener logFileListener = new FlatFileTraceListener(fileName, "", "", formatter);
        //// My collection of TraceListeners. 
        LogSource mainLogSource =
            new LogSource("FlatFile TraceListener", SourceLevels.All);
        mainLogSource.Listeners.Add(logFileListener);

        //// Assigning a non-existant LogSource for Logging Application Block 
        //// Specials Sources I don't care about.Used to say "don't log".
        LogSource nonExistantLogSource = new LogSource("Empty");

        //// I want all messages with a category of "User" or "Developer" to get distributed
        //// to all TraceListeners in my mainLogSource.
        IDictionary<string, LogSource> traceSources =
                      new Dictionary<string, LogSource>();
        traceSources.Add("User", mainLogSource);
        traceSources.Add("Developer", mainLogSource);

        // Let's glue it all together.
        // No filters at this time.
        // I won't log a couple of the Special
        // Sources: All Events and Events not
        // using "Error" or "Debug" categories.
        writer = new LogWriter(new ILogFilter[0],
                        traceSources,
                        nonExistantLogSource,
                        nonExistantLogSource,
                        mainLogSource,
                        "ALL",
                        false,
                        true);

    }

    /// <summary>
    /// Creating log writer programatically 
    /// </summary>
    static public void CreateLogWriterFromCode(string folder, string fileName) {
        if (eskoLoggingWriter == null) {
            //// The formatter is responsible for the look of the message. Notice the tokens: {timestamp}, {newline}, {message}, {category}
            TextFormatter formatter = new TextFormatter
                ("[{timestamp}]" + "[{category}]" + "{message}{newline}");

            //// Log messages to a log file. Use the formatter mentioned above specified.

            string date = String.Format("{0:yyyyMMdd}", DateTime.Now);
            FlatFileTraceListener logFileListener = new FlatFileTraceListener(folder + "/" + fileName + "_" + date + ".log", "", "", formatter);
            WmiTraceListener wmiListener = new WmiTraceListener();
            //// My collection of TraceListeners. 
            LogSource mainLogSource =
                new LogSource("FlatFile TraceListener", SourceLevels.All);
            LogSource wmiMainLogSource = new LogSource("WmiTraceListener", SourceLevels.All);
            mainLogSource.Listeners.Add(logFileListener);
            wmiMainLogSource.Listeners.Add(wmiListener);

            //// Assigning a non-existant LogSource for Logging Application Block 
            //// Specials Sources I don't care about.Used to say "don't log".
            LogSource nonExistantLogSource = new LogSource("Empty");

            //// I want all messages with a category of "User" or "Developer" to get distributed
            //// to all TraceListeners in my mainLogSource.
            IDictionary<string, LogSource> traceSources =
                          new Dictionary<string, LogSource>();
            traceSources.Add("User", mainLogSource);
            traceSources.Add("Developer", mainLogSource);

            IDictionary<string, LogSource> wmiTraceSources =
                                     new Dictionary<string, LogSource>();
            wmiTraceSources.Add("Instrumentation", wmiMainLogSource);

            // Let's glue it all together.
            // No filters at this time.
            // I won't log a couple of the Special
            // Sources: All Events and Events not
            // using "Error" or "Debug" categories.
            eskoLoggingWriter = new LogWriter(new ILogFilter[0],
                            traceSources,
                            nonExistantLogSource,
                            nonExistantLogSource,
                            mainLogSource,
                            "ALL",
                            false,
                            true);

            wmiWriter = new LogWriter(new ILogFilter[0],
                           wmiTraceSources,
                           nonExistantLogSource,
                           nonExistantLogSource,
                           wmiMainLogSource,
                           "All",
                           true,
                           true);
        }
    }
}

In Global.asax, add these line in Application_Start

void Application_Start(object sender, EventArgs e) {
        // Code that runs on application startup
        Utility.CreateLogWriterFromCode(ConfigurationSettings.AppSettings["LogFolder"].Trim(), ConfigurationSettings.AppSettings["LogFileName"].Trim());
        Utility.LogUserMessage("******** Application_Start Event My Login application started   ******", 1, System.Diagnostics.TraceEventType.Information);
}

Now wherver you want to log a message, use

Utility.LogUserMessage

You might have to make minor changes to the Utility class if EntLib 5 is used. That should be trivial.

So there you have, a log file on daily basis with correct data for that day. Again thank you to the anonymus person who wrote the Utility class in the first place. Hope this helps.

Regards.