How to use Log4net TelnetAppender and Trace Listeners

10 Nov 2006 11:59 AM

anonieko

Is there a way to use Log4net and Trace Listeners?

>> Hello,
>> I found this code somewhere
>>
>> -segt

AssembyInfo.cs
-----------------------

// This tells Log4Net to look for a Log4Net.config file in the
execution directory,
// in this case, the webroot. This file contains Log4Net configuration
settings.
[assembly:log4net.Config.XmlConfigurator(ConfigFile="Log4Net.config",Watch=true)]

log4net.config
--------------------

<?xml version="1.0" encoding="utf-8" ?>
<log4net>

    <appender name="tnet" type="log4net.Appender.TelnetAppender">
        <port value="49232" />
        <layout type="log4net.Layout.PatternLayout">
        
            <conversionPattern value="%m%n" />
        </layout>
    </appender>

    <root>
        <level value="ALL" />
        <appender-ref ref="tnet" />
    </root>
</log4net>

-----In your program, include the namespace

using log4net;

namespace Riag.Applications.Common
{

   public sealed class Tracer
   {
      private static readonly ILog Log =
LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

      public static void WriteError( string msg )
      {
         string prefix = LogLinePrefix() + " ERROR";
         Trace.WriteLineIf(_appSwitch.TraceError, msg, prefix );
         Log.Error( prefix+ ": " + msg);
      }

etc

=====
Entire source

//---------------------------------------------------------------
// 2003-09-01     ERV   Initial Version
// 2005-02-15     ERV   Improve the creation of textwriter files.

using System;
using System.Diagnostics;
using System.Configuration;
using System.IO;
using System.Reflection;
using log4net;

namespace Riag.Applications.Common
{
   /// <summary>
   /// Provides tracing for applications using System.Diagnotics
classes.
   /// <para>= (2003).</para>
   /// </summary>
   /// <remarks>
   /// <para>
   /// Tracer will perform custom trace output specified in
   /// the applications Configuration Settings.   Specifically
   /// designed for console applications. Tracer makes trace log
   /// ouputs uniform as much as possible. This class can not be
instantiated.
   /// </para>
   /// <para>
   /// Here is a sample code:
   /// </para>
   /// <code>
   /// // Sample Setup Logger for Console App. Option 1
   ///
   /// string LogDirectory      =
Utility.GetConfigurationAppSettings("LogDirectory");
   /// string TraceOutputs      =
Utility.GetConfigurationAppSettings("TraceOutputs");
   /// Tracer.Initialize( TraceOutputs, LogDirectory );
   ///
   /// // Sample Setup Logger for Console App. Option 1
   /// Tracer.DefaultInitialize(null);
   ///
   /// // Setup Logger for We application page
   /// // 'this' is a reference to a Page object
   /// Tracer.DefaultInitialize(this);
   /// </code>
   ///
   /// Here is a sample .config entry:
   /// <code>
   /// <configuration>
   /// <appSettings>
   /// <add key="LogDirectory" value="logs/" />
   /// <add key="TraceOutputs" value="test1.txt" />
   /// </appSettings>
   /// <system.diagnostics>
   /// <switches>
   /// <add name="app" value="4" />
   /// </switches>
   /// </system.diagnostics>
   /// </configuration>
   /// </code>
   /// </remarks>
   public sealed class Tracer
   {
      private static readonly ILog Log =
LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

      private Tracer() {}

      /// <summary>
      /// The private applications trace switch. This should be
initialized
      /// during application start.
      /// </summary>
      private static TraceSwitch _appSwitch;

      /// <summary>Empty constructor</summary>
      /// <summary>The public trace swith property</summary>
      public static TraceSwitch AppSwitch
      {
         get { return _appSwitch; }
      }

      enum Duration
      {
         Daily,
         Weekly,
         Monthly
      }

      /// <summary>Initialize with the default formatting of yyMMdd_,
and weekly interval</summary>
      public static void Initialize(string traceListeners, string
logDir )
      {
         Initialize( traceListeners, logDir, "yyMMdd_",
Tracer.Duration.Weekly); // using fix params for now
      }

      /// <summary>Tracer initialization method</summary>
      /// <remarks>
      /// Set the built-in Trace object to a specified listener
      /// which can be combination of the following: console,
      /// eventlog, or a trace file. Trace file are named,
      /// YYMMDD_filename.txt.
      /// </remarks>
      /// <param name="traceListeners">Comma separated list of
listeners</param>
      /// <param name="logDir">Absolute path of log directory</param>
      /// <param name="filePrefixDatePattern"></param>
      /// <param name="duration"></param>
      private static void Initialize(string traceListeners, string
logDir, string filePrefixDatePattern , Tracer.Duration duration )
      {
         // PUT SOMETHING LIKE THIS IN YOUR .CONFIG FILE
         //
         //   <?xml version="1.0" encoding="utf-8" ?>
         //   <configuration>
         //   <appSettings>
         //      <add key="LogDirectory" value="logs/" />
         //      <add key="TraceOutputs" value="CardW.txt" />
         //   </appSettings>
         //   <system.diagnostics>
         //      <switches>
         //         <add name="app" value="4" />
         //      </switches>
         //   </system.diagnostics>
         //   </configuration>

         _appSwitch = new TraceSwitch("app", "Entire Application");

         Trace.IndentSize = 2;
         Trace.AutoFlush = true;
         string listenersString = traceListeners;
         string directoryString = logDir; // this must be an absolute
path.

         if ( directoryString.Trim().Length != 0 )
            directoryString = Utility.AdjustDirPath(directoryString);
// make sure it ends with

         string[] arrListeners = listenersString.Split(',');

         if ( arrListeners != null )
         {
            // Add each to the Trace objects's listeners
            foreach ( string listener in arrListeners )
            {
               if ( listener.Trim().ToLower() == "console" )
               {
                  Trace.Listeners.Add(new
TextWriterTraceListener(Console.Out));

               }
               else if ( listener.Trim().ToLower() == "eventlog" )
               {
                  Trace.Listeners.Add( new EventLogTraceListener());

               }

               else
               {
                  // Ok. Interpret the listener string as a filename
suffix for a text log.
                  //
                  try
                  {
                     // Try to create the log directory
                     //
                     if ( ! Directory.Exists( directoryString) )
                     {
                        Directory.CreateDirectory( directoryString);
                     }

                     if ( Directory.Exists( directoryString) )
                     {

                        DateTime weekEnd = GetEndingDay(DateTime.Now,
duration);
                        string listenerPadded =
weekEnd.ToString(filePrefixDatePattern )
                           + listener.Trim();

                        AddTextWriterListener( directoryString +
listenerPadded );
                     }
                  }
                  catch(Exception excp)
                  {
                     string errorMsg = "ERROR: Unable to Create Trace
to " + listener + "-" + excp.Message;

                     // last resort
                     Flush2File("c:\\Tracer.Err.txt" , errorMsg, true);
                  }
               }

            }

         }
      }

      /// <summary>
      /// Write append to a text file
      /// </summary>
      /// <param name="file"></param>
      /// <param name="msg"></param>
      /// <param name="append"></param>
      public static void Flush2File(string file, string msg, bool
append)
      {
         try
         {
            using ( StreamWriter sw = new StreamWriter(file, append) )
            {
               sw.Write( msg);

               sw.Close();
            }

         }
         catch
         {
            throw;
         }
      }

      /// <summary>
      /// Returns the date of the next Sunday from a given date.
      /// </summary>
      /// <param name="dt">Starting date</param>
      /// <param name="duration"></param>
      /// <returns></returns>
      private static DateTime GetEndingDay ( DateTime dt, Duration
duration)
      {
         switch( duration )
         {
            case Duration.Weekly:
               while (dt.DayOfWeek != System.DayOfWeek.Sunday )
               {
                  dt = dt.AddDays(1);
               }
               break;

         }

         return dt;
      }

      /// <summary/>
      public static void DefaultInitialize(object logObject)
      {
         // Initialize log system
         string logDirectory      =
Utility.GetConfigurationAppSettings("LogDirectory");
         string traceOutputs      =
Utility.GetConfigurationAppSettings("TraceOutputs");

         // Convert into absolute path if coming from a page object
(i.e. web app)
         System.Web.UI.Page page = logObject as System.Web.UI.Page;
         if ( page != null)
         {
            if ( ! Path.IsPathRooted( logDirectory) )
            {
               logDirectory = page.Server.MapPath(logDirectory);
            }
         }

         Tracer.Initialize( traceOutputs, logDirectory);
      }

      #region public Write Functions
      /// <summary>
      /// Writes error message to Trace.
      /// </summary>
      /// <param name="msg"></param>
      public static void WriteError( string msg )
      {
         string prefix = LogLinePrefix() + " ERROR";
         Trace.WriteLineIf(_appSwitch.TraceError, msg, prefix );
         Log.Error( prefix+ ": " + msg);
      }
      /// <summary>
      ///
      /// </summary>
      /// <param name="format"></param>
      /// <param name="args"></param>
      public static void WriteError( string format, params object[]
args)
      {
         WriteError(System.String.Format(format, args));
      }
      /// <summary>
      /// Writes warning message to Trace.
      /// </summary>
      /// <param name="msg"></param>
      public static void WriteWarning( string msg )
      {
         string prefix = LogLinePrefix() + " WARN";
         Trace.WriteLineIf(_appSwitch.TraceWarning, msg, prefix );
         Log.Warn( prefix+ ": " + msg);
      }
      /// <summary>
      ///
      /// </summary>
      /// <param name="format"></param>
      /// <param name="args"></param>
      public static void WriteWarning( string format, params object[]
args)
      {
         WriteWarning(System.String.Format(format, args));
      }
      /// <summary>
      /// Write Informational message to Trace.
      /// </summary>
      /// <param name="msg"></param>
      public static void WriteInfo( string msg )
      {
         string prefix = LogLinePrefix() + " INFO";
         Trace.WriteLineIf(_appSwitch.TraceInfo, msg, prefix );
         Log.Info( prefix+ ": " + msg);
      }
      /// <summary>
      ///
      /// </summary>
      /// <param name="format"></param>
      /// <param name="args"></param>
      public static void WriteInfo( string format, params object[]
args)
      {
         WriteInfo(System.String.Format(format, args));
      }
      /// <summary>
      /// Write verbose message to Trace.
      /// </summary>
      /// <param name="msg"></param>
      public static void WriteVerbose( string msg )
      {
         string prefix = LogLinePrefix() + " VERB";
         Trace.WriteLineIf(_appSwitch.TraceVerbose, msg, prefix );
         Log.Debug( prefix+ ": " + msg);
      }
      /// <summary>
      ///
      /// </summary>
      /// <param name="format"></param>
      /// <param name="args"></param>
      public static void WriteVerbose( string format, params object[]
args)
      {
         WriteVerbose(System.String.Format(format, args));
      }
      /// <summary>
      /// Writes debug message to Debug object.
      /// </summary>
      /// <param name="msg"></param>
      public static void WriteDebug( string msg )
      {
         string prefix = LogLinePrefix() + " DEBUG";
         Debug.WriteLineIf(_appSwitch.TraceVerbose, msg, prefix );
         Log.Debug( prefix+ ": " + msg);
      }
      /// <summary>
      ///
      /// </summary>
      /// <param name="format"></param>
      /// <param name="args"></param>
      public static void WriteDebug( string format, params object[]
args)
      {
         WriteDebug(System.String.Format(format, args));
      }

      private static string LogLinePrefix()
      {
         return DateTime.Now.ToString( "yy/MM/dd HH:mm:ss:fff") + "["
+ Environment.MachineName + "]" ;
      }

      #endregion

      #region Helper Methods

      // This method is a safe way to add a TextWriterListener to the
      // Trace.Listeners collection. It ensures that only 1
      // TextWriterTraceListener is active at a time. If it detects
that
      // the object exists, it will not add. If filename changes, it
will
      // close all TextWriterTraceListeners, and add the new one.
      private static bool AddTextWriterListener( string
fullPathFilename)
      {
         bool returnValue = false;

         // this will safely cast object to a type becaue it return
null if not compatible.
         TextWriterTraceListener currTextWriter =
Trace.Listeners[fullPathFilename] as TextWriterTraceListener;

         if ( currTextWriter == null)
         {
            // The listner is not yet in the list. It maybe a different
filename
            // or new filename. We should then close and remove all
TextWriterTraceListeners
            // from TraceListeners.
            RemoveTextWriterListeners();

            // Add the new listener
            Trace.Listeners.Add( new
TextWriterTraceListener(fullPathFilename, fullPathFilename));

            returnValue = true;
         }

         return returnValue;
      }

      // Iterate through the built-in Trace.Listeners collection
      // and remove the TextWriterTraceListener objects. Be sure
      // to close the object first.
      private static void RemoveTextWriterListeners()
      {
         foreach( object l in Trace.Listeners)
         {
            TextWriterTraceListener aListener = l as
TextWriterTraceListener;
            if ( aListener != null )
            {
               aListener.Close();
               Trace.Listeners.Remove(aListener);
            }
         }
      }

      #endregion

   }
}

#region Junks
//
//#region The Singleton Pattern in C#
//
//private static volatile Tracer   instance;
//private static object syncRoot = new Object();
//
//
//      /// <summary>
//      ///
//      /// </summary>
//public static Tracer Instance
//{
//get
//{
//if (instance == null)
//{
//lock (syncRoot)
//{
//if (instance == null)
//instance = new Tracer();
//}
//}
//
//return instance;
//}
//}
//#endregion
#endregion

13 Nov 2006 9:24 PM

anonieko

This is a very practical guide to start using log4net quickly. Log4net
is the most common and standard tool to be used to log C# applications.
This tool can write logs in log files, database log table or xml files.
(There is some other ways to write logs too)

1- Download log4net from http://logging.apache.org/log4net/
2- In Visual Studio->WebSite->AddReference add a new reference do
log4net.dll that you downloaded.
3- Put this in the beginning of web.config file:
    <configSections>
        <section name="log4net"
type="log4net.Config.Log4NetConfigurationSectionHandler,Log4net"/>
    </configSections> ...

4- Now put this in the end of web.config file:

    <log4net>
        <logger name="default">
            <level value="DEBUG"/>
        </logger>
        <root>
            <level value="WARN" />
            <appender-ref ref="LogFileAppender" />
        </root>
        <appender name="LogFileAppender"
type="log4net.Appender.RollingFileAppender" >
            <param name="File" value="log/log.txt" />
            <param name="AppendToFile" value="true" />
            <rollingStyle value="Size" />
            <maxSizeRollBackups value="10" />
            <maximumFileSize value="10MB" />
            <staticLogFileName value="true" />
            <layout type="log4net.Layout.PatternLayout">
                <param name="ConversionPattern" value="%-5p
%d{yyyy-MM-dd hh:mm:ss} - %m%n" />
            </layout>
        </appender>
    </log4net>

this configuration creates a log file in ~/log/log.txt.

5- To use log4net put this as a local class variable:
   protected static readonly ILog log =
LogManager.GetLogger("default");

6- And do this to write messages in the log file.
   log.Debug("this text will be in log file");

7- A very good program to read log files is called BareTail, you can
find it easily.
8- This is an example class - Example.cs
9- This is all you need to start using log4net