Introduction à log4net

Log4net est un outil pour aider le développeur à logger des informations vers diverses cibles. Log4net est un port de l'excellent framework log4j vers .NET.

Le site officiel est http://logging.apache.org/log4net/

Log4net a trois composants principaux : les loggers, appenders et layouts :

• les loggers : définissent le type de message ainsi que son niveau ;
• les appenders : destination du message ;
• les layouts : formatage du message.

Ces trois types de composants travaillent ensemble pour permettre le log des messages selon leur type et niveau, contrôler leur format et leur journalisation. Ces composants sont aidés par les filters qui commandent les actions de l'appender et les object renderers qui transforment des objets en chaînes de caractères.

L'avantage principal de toute API de log face à un trivial System.Console.WriteLine réside dans la possibilité de désactiver/activer le log de certains messages en fonction de leur état et niveau. Cette fonctionnalité implique une hiérarchisation selon des critères choisis par le développeur.

Des niveaux peuvent être assignés aux loggers. Les niveaux sont des instances de la classe log4net.Core.Level. Les niveaux suivants sont définis par ordre de priorité croissante :

• ALL ;
• DEBUG ;
• INFO ;
• WARN ;
• ERROR ;
• FATAL ;
• OFF.

Log4net permet de logger vers de multiples destinations via l'utilisation d'appenders.

La liste des appenders disponibles est la suivante :

Il est possible d'associer plusieurs appenders à un logger afin d'écrire la même information en plusieurs endroits différents. On peut par exemple souhaiter que lorsqu'une exception est levée dans notre application, l'information soit écrite dans un fichier texte, mais également envoyée par mail.

Les appenders peuvent filtrer les évènements qui leur sont fournis. Les filtres peuvent être indiqués dans la configuration pour permettre un contrôle précis des évènements qui sont inscrits par les différents appenders. La façon la plus simple est d'indiquer un seuil sur l'appender. Seuls les évènements qui ont un niveau supérieur ou égal au seuil seront inscrits.

Les filtres suivants sont inclus dans le package de log4net :

Le plus souvent, les utilisateurs souhaitent adapter non seulement la destination des informations à logger mais également leur format de sortie. Ceci est accompli en associant un layout à un appender. Le layout est en charge du formatage du message selon les souhaits de l'utilisateur, tandis qu'un appender prend soin d'envoyer le message composé à sa destination. Le PatternLayout, permet à l'utilisateur d'indiquer le format de message parmi des modèles de conversion semblables à ceux de la fonction printf du langage C.

Les layouts suivants sont inclus dans le package de log4net :

Voyons l'utilisation du BasicConfigurator via une application console très simple.

using System;
using log4net;
using log4net.Config;

public class Program
{
    // On définit une variable logger static qui référence l'instance du logger nommé Program
    private static readonly ILog log = LogManager.GetLogger(typeof (Program));

    static void Main(string[] args)
    {
        // On charge la configuration de base qui log dans la console
        BasicConfigurator.Configure();

        log.Info("Démarrage de l'application.");
        var task = new Task();
        task.Run();
        log.Info("Fin de l'application.");
        Console.ReadLine();
    }
}


public class Task
{
    private static readonly ILog log = LogManager.GetLogger(typeof(Task));

    public void Run()
    {
        log.Debug("Lancement de la tâche");
    }
}

On commence par importer les classes nécessaires à l'utilisation de log4net. On définit ensuite une variable logger static qui porte le même nom que la classe où elle se trouve.

L'appel de la méthode BasicConfigurator.Configure() charge une configuration par défaut de log4net. Cette méthode ajoute un ConsoleAppender au logger root. L'information sera formaté suivant le pattern suivant (plus de détails sur les ConversionPatters ) : « %-4timestamp [%thread] %-5level %logger %ndc - %message%newline ». Par défaut, le niveau du logger root est Level.DEBUG.

La sortie de Program est :

BasicConfigurator ne permet que des configurations très simples de log4net. Seulement un appender peut être configuré en utilisant ce configurateur et toutes les informations seront loggées via cet appender.

Pour plus d'informations, BasicConfigurator Class.

L'exemple précédent produit toujours la même sortie. Heureusement, il est facile de modifier la classe Program afin de contrôler le format des logs pendant le runtime via le configurateur XmlConfigurator.

Le XmlConfigurator permet de charger une configuration définie dans un fichier séparé. Cela permet de modifier la façon dont les informations sont loggées sans avoir à recompiler l'application.

Pour plus d'informations, XmlConfigurator Class.

Reprenons l'application précédente et intégrons-y le XmlConfigurator.

La class Program ressemble maintenant à :

using System;
using log4net;
using log4net.Config;

public class Program
{
    // On définit une variable logger static qui référence l'instance du logger nommé Program
    private static readonly ILog log = LogManager.GetLogger(typeof (Program));

    static void Main(string[] args)
    {
        // On récupère le chemin du fichier de config
        var configFile = Directory.GetCurrentDirectory() + @"\log4net.config";

        // On remplace le BasicConfigurator par le XmlConfigurator
        // et on charge la configuration définie dans le fichier log4net.config
        XmlConfigurator.Configure(new FileInfo(configFile));

        log.Info("Démarrage de l'application.");
        var task = new Task();
        task.Run();
        log.Info("Fin de l'application.");
        Console.ReadLine();
    }
}

Voilà un exemple de fichier de config qui donne exactement le même résultat que l'exemple précédent avec le BasicConfigurator.

<log4net>
  <!-- A1 est un ConsoleAppender -->
  <appender name="A1" type="log4net.Appender.ConsoleAppender">

    <!-- A1 utilise un PatternLayout -->
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" />
    </layout>
  </appender>

  <!-- On définit le logger root au niveau DEBUG et on l'associe à l'appender A1 -->
  <root>
    <level value="DEBUG" />
    <appender-ref ref="A1" />
  </root>
</log4net>

Supposons maintenant que nous souhaitions que le logger « Task » (utilisé dans la classe Task) ne logge plus que des informations dont le niveau est supérieur ou égal au niveau WARN.

Le fichier de configuration suivant permet cela :

<log4net>
  <!-- A1 est un ConsoleAppender -->
  <appender name="A1" type="log4net.Appender.ConsoleAppender">

    <!-- A1 utilise un PatternLayout -->
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" />
    </layout>
  </appender>

  <!-- On définit le logger root au niveau DEBUG et on l'associe à l'appender A1 -->
  <root>
    <level value="DEBUG" />
    <appender-ref ref="A1" />
  </root>
  <!-- On ne loggue que les informations dont le niveau est supérieur à WARN pour le logger Task -->
  <logger name="Task">
    <level value="WARN"/>
  </logger>
</log4net>

La sortie de l'application est maintenant :

Voici un autre exemple de fichier de configuration qui utilise plusieurs appenders :

<log4net>
  <appender name="A1" type="log4net.Appender.ConsoleAppender">
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" />
    </layout>
  </appender>
  <appender name="RollingFile" type="log4net.Appender.RollingFileAppender">
    <file value="example.log" />
    <appendToFile value="true" />
    <maximumFileSize value="100KB" />
    <maxSizeRollBackups value="2" />
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%level %thread %logger - %message%newline" />
    </layout>
  </appender>
  <root>
    <level value="DEBUG" />
    <appender-ref ref="A1" />
    <appender-ref ref="RollingFile" />
  </root>
</log4net>

On remarque qu'un second appender a été associé au logger root.

Les informations seront maintenant également loggées dans un fichier example.log.

Dès que le fichier atteindra 100KB, un nouveau fichier example.log sera créé et l'ancien sera automatiquement renommé en example.log.1.

Comme vous avez pu le voir, on a modifié dynamiquement la façon dont les informations sont loggées.

Log4net peut être configuré en utilisant des attributs au niveau de l'assembly plutôt qu'au niveau du code.

La classe XmlConfiguratorAttribute permet au XmlConfigurator d'être configuré en utilisant les propriétés suivantes :

• ConfigFile : si spécifié, correspond au nom du fichier de configuration utilisé par le XmlConfigurator. Le chemin est relatif au dossier de base de l'application (AppDomain.CurrentDomain.BaseDirectory). Cette propriété ne peut pas être utilisée conjointement avec la propriété ConfigFileExtension ;
• ConfigFileExtension : si spécifié, correspond à l'extension du fichier de configuration. Le nom du fichier de l'assembly est utilisé comme base à laquelle on ajoute l'extension. Par exemple, si l'assembly est chargée depuis un fichier MyApp.exe et que l'extension est log4net, alors le nom du fichier de configuration sera MyApp.exe.log4net. Cette propriété ne peut pas être utilisée conjointement avec la propriété ConfigFile ;
• Watch : si ce flag est à true, le framework « surveillera » le fichier de configuration et rechargera la configuration à chaque modification du fichier.

Cet attribut ne peut être utilisé qu'au niveau de l'assembly et ne peut être utilisé qu'une fois par assembly.

Exemple d'utilisation :

[assembly: log4net.Config.XmlConfigurator(ConfigFile = "Config/Log4Net. config", Watch = true)]
public static class Log
{
    
}

Généralement, le paramétrage de log4net est spécifié via un fichier de configuration. Ce fichier peut être lu de deux façons :

• en utilisant l'API .NET System.Configuration ;
• en lisant directement le fichier.

II-D-1. Les fichiers .config▲

<configSections>
<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
</configSections>

<log4net>
    <appender name="SmtpAppender" type="log4net.Appender.SmtpAppender,log4net">
      <to value="destinataire@mail.com" />
      <from value="expediteur@mail.com" />
      <subject value="Alerte, tout a pété" />
      <smtpHost value="smtp.com" />
      <bufferSize value="0" />
      <threshold value="ERROR" />
      <layout type="log4net.Layout.PatternLayout,log4net">
        <conversionPattern value="LEVEL: %level %newlineDATE: ?te  LOGGER: %logger %newline%newline%message" />
      </layout>
    </appender>
    <root> 
      <level value="ALL" /> 
      <appender-ref ref="SmtpAppender" />
    </root>
  </log4net>

II-D-2. Lire un fichier directement▲

<?xml version="1.0" encoding="utf-8" ?>
<log4net>
  <appender name="Console" type="log4net.Appender.ConsoleAppender">
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" />
    </layout>
  </appender>
  <root>
    <level value="DEBUG" />
    <appender-ref ref="Console" />
  </root>
</log4net>

Ce paragraphe a pour but de définir la syntaxe acceptée par log4net.Config.XmlConfigurator.

Reprenons l'exemple précédent.

<?xml version="1.0" encoding="utf-8" ?>
<log4net>
  <appender name="Console" type="log4net.Appender.ConsoleAppender">
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" />
    </layout>
  </appender>
  <root>
    <level value="DEBUG" />
    <appender-ref ref="Console" />
  </root>
</log4net>

L'élément racine doit être <log4net>. Cela ne signifie pas que cet élément ne peut pas être contenu dans un autre élément XML.

L'élément <log4net> accepte les attributs suivants:

L'élément <log4net> accepte les éléments enfants suivants :

II-E-1. Les appenders▲

  <appender name="Console" type="log4net.Appender.ConsoleAppender">
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" />
    </layout>
  </appender>

II-E-2. Les filters.▲

<filter type="log4net.Filter.LevelRangeFilter">
   <levelMin value="INFO" />
   <levelMax value="FATAL" />
</filter>

<filter type="log4net.Filter.StringMatchFilter">
  <stringToMatch value="database" />
</filter>
<filter type="log4net.Filter.DenyAllFilter" />

<filter type="log4net.Filter.StringMatchFilter">
  <stringToMatch value="database" />
</filter>
<filter type="log4net.Filter.StringMatchFilter">
  <stringToMatch value="ldap" />
</filter>
<filter type="log4net.Filter.DenyAllFilter" />

II-E-3. Les layouts▲

<layout type="log4net.Layout.PatternLayout">
  <conversionPattern value="?te [%thread] %-5level %logger [%ndc] - %message%newline" />
</layout>

II-E-4. Le root logger▲

<root>
  <level value="INFO" />
  <appender-ref ref="ConsoleAppender" />
</root>

II-E-5. Les loggers▲

<logger name="LoggerName">
  <level value="DEBUG" />
  <appender-ref ref="ConsoleAppender" />
</logger>

II-E-6. Les renderers▲

<renderer renderingClass="MyClass.MyRenderer"  renderedClass="MyClass.MyFunkyObject" />

II-E-7. Les paramètres▲

<param name="ConversionPattern" value="?te [%thread] %-5level %logger [%ndc] - %message%newline" />

<param name="evaluator" type="log4net.spi.LevelEvaluator">
  <param name="Threshold" value="WARN"/>
<param>

II-E-8. Les ConversionPatterns▲

• La construction de chaîne de caractères est très consommatrice en ressources. Afin de ne pas en construire inutilement, vérifier que le logger est bien configuré avec un niveau de log suffisant :

if(Log.MainLogger.IsDebugEnabled)
{
      //construction de la chaîne de caractères consommatrice en ressources
      // TODO
Log.MainLogger.Debug(msg);
}

• Faciliter la visualisation des logs : mettre ce qui est fixe au début (comme le niveau du log ou le nom du logger), ce qui est variable à la fin (comme le message loggé).

Exemple : [DEBUG] - TaskLogger - 09/12/2008 00:12:54 - Construction de l'objet Task

Attaquons dans le vif du sujet avec le fichier de configuration de log4net. Comme vu précédemment, ce fichier permet principalement de définir quelles informations seront loggées, de quelle manière, vers quel support.

Voilà le fichier de configuration dans son intégralité :

<log4net debug="true" >
  <appender name="AspNetTraceAppender" type="log4net.Appender.AspNetTraceAppender" >
    <threshold value="ALL"/>
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="[%level] ?te %logger - %message" />
    </layout>
  </appender>
  <appender name="EventLogAppender" type="log4net.Appender.EventLogAppender" >
    <applicationName value="Log4net.WebApp" />
    <filter type="log4net.Filter.LevelRangeFilter">
      <levelMin value="DEBUG" />
      <levelMax value="INFO" />
    </filter>
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="[%level] ?te %logger - %message" />
    </layout>
  </appender>
  <appender name="DatabaseAppender" type="log4net.Appender.AdoNetAppender">
    <bufferSize value="0" />
    <threshold value="ERROR" />
    <connectionString value="Provider=SQLOLEDB;Data Source=PASCAL-PC\SQLEXPRESS;Database=Logs;Trusted_Connection=yes" />
    <commandText value="INSERT INTO Logs(Date, Level, Who, Message) VALUES(?, ?, ?, ?)" />
    <parameter>
      <parameterName value="@Date" />
      <dbType value="DateTime" />
      <size value="255" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="?te{yyyy'-'MM'-'dd HH':'mm}" />
      </layout>
    </parameter>
    <parameter>
      <parameterName value="@Level" />
      <dbType value="AnsiString" />
      <size value="10" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%level" />
      </layout>
    </parameter>
    <parameter>
      <parameterName value="@Who" />
      <dbType value="AnsiString" />
      <size value="100" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%property{log_who}" />
      </layout>
    </parameter>
    <parameter>
      <parameterName value="@Message" />
      <dbType value="AnsiString" />
      <size value="500" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%message" />
      </layout>
    </parameter>
  </appender>
  <appender name="SmtpAppender" type="log4net.Appender.SmtpAppender,log4net">
    <to value="votre adresse mail" />
    <from value="logger@webapp.com" />
    <subject value="Alerte dans AppWeb" />
    <smtpHost value="l'adresse du smtp" />
    <bufferSize value="0" />
    <threshold value="DEBUG" />
    <layout type="log4net.Layout.PatternLayout,log4net">
      <conversionPattern value="LEVEL: %level %newlineDATE: ?te  %newlineLOGGER: %logger %newline%newline%message" />
    </layout>
  </appender>
  <appender name="RollingFile" type="log4net.Appender.RollingFileAppender">
    <file value="Log/Log.txt"/>
    <threshold value="INFO"/>
    <appendToFile value="true"/>
    <rollingStyle value="Date"/>
    <datePattern value="yyyyMMdd"/>
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="*%-10level %-30date %-25logger %message %newline"/>
    </layout>
  </appender>
  <root>
    <level value="ALL"/>
  </root>
  <logger name="MonitoringLogger">
    <level value="ALL"/>
    <appender-ref ref="RollingFile"/>
    <appender-ref ref="DatabaseAppender"/>
    <appender-ref ref="AspNetTraceAppender"/>
    <appender-ref ref="EventLogAppender"/>
  </logger>
  <logger name="ExceptionLogger">
    <level value="ERROR"/>
    <appender-ref ref="SmtpAppender"/>
    <appender-ref ref="RollingFile"/>
  </logger>
</log4net>

Détaillons plus précisément le contenu de ce fichier en commençant par les appenders.

On peut voir cinq appenders différents, c'est-à-dire qu'on pourra logger vers cinq destinations différentes :

• SmtpAppender

<appender name="SmtpAppender" type="log4net.Appender.SmtpAppender,log4net">
    <to value="votre adresse mail" />
    <from value="logger@webapp.com" />
    <subject value="Alerte dans AppWeb" />
    <smtpHost value="l'adresse du smtp" />
    <bufferSize value="0" />
    <threshold value="DEBUG" />
    <layout type="log4net.Layout.PatternLayout,log4net">
      <conversionPattern value="LEVEL: %level %newlineDATE: ?te  %newlineLOGGER: %logger %newline%newline%message" />
    </layout>
 </appender>

Ici, on a créé un appender de type SmtpAppender dont le but est d'envoyer un mail.

Les éléments to, from, smtpHost et subject se passent de commentaires.

L'élément threshold définit le niveau minimum auquel doit être associé l'évènement pour être logué. Ici, tout évènement d'un niveau égal ou supérieur à DEBUG sera loggé.

L'élément bufferSize définit la taille du buffer cyclique utilisé. Par défaut, la valeur est 512K, autrement dit, un mail sera envoyé dès que le buffer atteindra une taille de 512K. Ici, une valeur nulle implique un envoi de mail pour chaque évènement.

L'élément conversionPattern définit le template de l'information loggée. Ici, on loggera le niveau de l'évènement, la date/heure actuelle, le nom du logger et le message.

• DatabaseAppender

<appender name="DatabaseAppender" type="log4net.Appender.AdoNetAppender">
    <bufferSize value="0" />
    <threshold value="ERROR" />
    <connectionString value="Provider=SQLOLEDB;Data Source=PASCAL-PC\SQLEXPRESS;Database=Logs;Trusted_Connection=yes" />
    <commandText value="INSERT INTO Logs(Date, Level, Who, Message) VALUES(?, ?, ?, ?)" />
    <parameter>
      <parameterName value="@Date" />
      <dbType value="DateTime" />
      <size value="255" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="?te" />
      </layout>
    </parameter>
    <parameter>
      <parameterName value="@Level" />
      <dbType value="AnsiString" />
      <size value="10" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%level" />
      </layout>
    </parameter>
    <parameter>
      <parameterName value="@Who" />
      <dbType value="AnsiString" />
      <size value="100" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%property{log_who}" />
      </layout>
    </parameter>
    <parameter>
      <parameterName value="@Message" />
      <dbType value="AnsiString" />
      <size value="500" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%message" />
      </layout>
    </parameter>
  </appender>

Cet appender sert à logger en base.

bufferSize = 0 indique que l'on logge à chaque évènement.

threshold à la valeur ERROR donc tout évènement ayant un niveau strictement inférieur à ERROR ne sera pas loggé.

connectionString correspond à la chaîne de connexion à la base.

commandText correspond à la requête paramétrée exécutée lors du log.

Les éléments parameters correspondent aux paramètres de la requête.

Ils doivent apparaître dans le même ordre que dans la requête.

Remarque : pour le paramètre log_who, on utilise la syntaxe :

<conversionPattern value="%property{log_who}" />

Cela signifie que l'on utilise une property de log4net que l'on définit à la main dans le code ()

• AspNetTraceAppender

<appender name="AspNetTraceAppender" type="log4net.Appender.AspNetTraceAppender" >
    <threshold value="ALL"/>
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="[%level] ?te %logger - %message" />
    </layout>
</appender>

Cet appender permet d'écrire dans la trace d'ASP.NET.

• EventLogAppender

<appender name="EventLogAppender" 
type="log4net.Appender.EventLogAppender" >
    <applicationName value="Log4net.WebApp" />
    <filter type="log4net.Filter.LevelRangeFilter">
      <levelMin value="DEBUG" />
      <levelMax value="INFO" />
    </filter>
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="[%level] ?te %logger - %message" />
    </layout>
</appender>

Cet appender permet d'écrire dans l'observateur d'évènements de Windows, dans la section Application.

applicationName permet de spécifier la source associée à l'évènement.

On utilise un filter de type LevelRangeFilter. Cela signifie que l'évènement sera loggé si son niveau est compris entre levelMin et levelMax. Autrement dit, ici, seuls les évènements ayant un niveau DEBUG ou INFO seront loggés.

• RollingFileAppender

  <appender name="RollingFile" type="log4net.Appender.RollingFileAppender">
    <file value="Log/Log.txt"/>
    <threshold value="INFO"/>
    <appendToFile value="true"/>
    <rollingStyle value="Date"/>
    <datePattern value="yyyyMMdd"/>
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="*%-10level %-30date %-25logger %message %newline"/>
    </layout>
  </appender>

Le RollingFileAppender, tout comme le FileAppender, permet de logger dans un fichier. Mais il permet en plus de renommer automatiquement les fichiers de logs suivant certains critères (date, taille du fichier).

file indique le chemin du fichier où seront écrits les logs.

appendToFile indique si le fichier sera écrasé (false) ou si le les logs seront écrits à la suite (true).

rollingStyle définit le critère suivant lequel sera renommé le fichier.

datePattern définit le pattern utilisé pour renommer le fichier quand le rollingStyle a la valeur Date.

Ici, on a datePattern = « yyyyMMdd ». Cela signifie que le 1^er jour, les logs seront écrits dans log.txt. Au deuxième jour, le fichier log.txt de la veille sera renommé en log.txt.20001205 (pour une date du jour étant 06/12/2008).

rollingStyle peut également avoir la valeur Size. Cela signifie que le fichier sera automatiquement renommé en log.txt.1 dès qu'il aura atteint une taille limite. Cette taille est définie avec le paramètre maximumFileSize. Exemple :

<rollingStyle value="Size"/>
<maximumFileSize value="100KB"/>

On peut également mixer les deux rollingStyles de la façon suivante :

<rollingStyle value="Composite"/>
<maximumFileSize value="1MB"/>
<datePattern value="yyyyMMdd"/>

Après les appenders, on définit le logger root, le logger par défaut :

<root>
    <level value="ALL"/>
</root>

On se contente d'y spécifier le niveau de log souhaité.

La suite consiste en créer les loggers que nous souhaitons utiliser dans l'application. Dans l'exemple présent, j'ai choisi de créer deux loggers :

• un logger général, appelé MonitoringLogger ;
• un logger spécialement dédié au log des erreurs et exceptions, appelé ExceptionLogger.

Pour créer un logger, il suffit d'ajouter un nœud logger dont l'attribut name correspond au nom que l'on souhaite donner au logger. On spécifie ensuite le niveau associé au logger, ainsi que les appenders associés.

  <logger name="MonitoringLogger">
    <level value="ALL"/>
    <appender-ref ref="RollingFile"/>
    <appender-ref ref="DatabaseAppender"/>
    <appender-ref ref="AspNetTraceAppender"/>
    <appender-ref ref="EventLogAppender"/>
  </logger>
  <logger name="ExceptionLogger">
    <level value="ERROR"/>
    <appender-ref ref="SmtpAppender"/>
    <appender-ref ref="RollingFile"/>
  </logger>

Ici, on peut voir que le logger MonitoringLogger a le niveau ALL, c'est-à-dire que tous les évènements seront loggés. Les évènements seront écrits dans un fichier, en base, dans la trace asp.net et dans le journal des évènements comme le montre la liste des appenders associés.

Quant à lui, le logger ExceptionLogger a le niveau ERROR étant donné que l'on souhaite ne logger que les erreurs et exceptions. Les évènements seront écrits dans un fichier et envoyés par mail.

Cette classe static permet de centraliser l'instanciation de log4net et la création des loggers.

using log4net;
using log4net.Config;

[assembly: XmlConfigurator(ConfigFile = "Config/Log4Net.config", Watch = true)]
namespace WebApp
{
    public static class Log
    {
        public static ILog MonitoringLogger
        {
            get { return LogManager.GetLogger("MonitoringLogger"); }
        }

        public static ILog ExceptionLogger
        {
            get { return LogManager.GetLogger("ExceptionLogger"); }
        }
    }
}

La ligne suivante :

[assembly: XmlConfigurator(ConfigFile = "Config/Log4Net.config", Watch = true)]

permet de spécifier le fichier de config de log4net. L'attribut Watch = true indique que la configuration de log4net sera automatiquement rechargée lors de toute modification du fichier de config.

Pour créer un logger, il faut appeler la méthode LogManager.GetLogger en lui passant comme paramètre l'attribut name de l'élément logger défini dans le fichier de config. Ici, on encapsule cet appel pour chacun des loggers en créant une propriété MonitoringLogger et une propriété ExceptionLogger. Il suffira d'appeler simplement ces propriétés pour logger les évènements souhaités.

La méthode GetLogger agit à la manière d'un singleton. Si le logger existe déjà, alors l'instance existante sera retournée. Sinon, une nouvelle instance est créée.

Pour logger un message, il suffit d'appeler le logger de son choix puis la fonction correspondant au niveau de l'évènement.

Par exemple, pour logger une erreur avec le logger ExceptionLogger, il suffit d'appeler :

Log.ExceptionLogger.Error(msg) où msg est le message à loguer.

Pour loguer une info de debug avec le logger MonitoringLogger, il faut appeler :

Log.MonitoringLogger.Debug(msg) où msg est le message à loguer.

Pour ajouter une propriété à celles de log4net (comme on a pu le voir pour l'appender), on utilise la syntaxe suivante :

log4net.ThreadContext.Properties["log_who"] = user;
Log.MonitoringLogger.Debug(msg);

Afin de mettre en pratique tout ça, je vous conseille d'exécuter le site web et d'observer comment les informations sont loggées. Une fois cette étape passée, vous pourrez modifier le fichier de configuration de log4net afin de vous familiariser avec la façon dont fonctionne log4net.

Si jamais log4net ne logge pas correctement, il est possible d'activer ses logs internes.

Pour cela, il suffit d'ajouter dans le Web.Config ou App.Config, les lignes suivantes :

<system.diagnostics>
<trace autoflush="true">
<listeners>
<add name="textWriterTraceListener" type="System.Diagnostics.TextWriterTraceListener" initializeData="Log\log4net_InternalDebug.txt"/>
</listeners>
</trace>
</system.diagnostics>

Il faut également rajouter la ligne suivante dans la section appSettings :

<add key="log4net.Internal.Debug" value="true"/>

Log4net écrira alors ses propres logs dans le fichier Log\log4net_InternalDebug.txt.

Il est également possible de spécifier un chemin absolu par exemple C:\Temp\ log4net_InternalDebug.txt.

Il est possible de désactiver tous les logs très simplement. Pour cela il suffit d'ajouter threshold=« OFF » dans le nœud log4net.

<log4net threshold="OFF">
  ...
</log4net>

Il existe quelques logiciels permettant de visualiser les logs de façon un peu plus conviviale que notepad.

Baretail est l'un de ces logiciels (disponible ici). Il permet notamment de visualiser les logs en surlignant les lignes qui contiennent des mots clés paramétrables et actualise automatique l'affichage lors de la modification du fichier.

Bien que log4net propose de très nombreux appenders, il se peut que vous ne trouviez pas celui qui réponde à votre besoin. Pour cela, il est possible de créer son propre appender. Cela sera abordé dans un prochain article.