Customiser log4net

Cette classe est la représentation interne de tout événement à logger. Elle expose des propriétés telles que le nom du logger, le niveau de l'événement, le message à logger .

Tous les appenders dérivent de la classe abstraite AppenderSkeleton, qui implémente entre autres l'interface IAppender.

Cette interface déclare la méthode DoAppend qui prend en paramètre un LoggingEvent :

void DoAppend(LoggingEvent loggingEvent);

Cette méthode est très importante pour nous car c'est elle qui est chargée de vérifier si l'événement doit être loggé (c'est-à-dire que les différents filtres ont été passés) et qui, le cas échéant, logge l'événement suivant l'appender utilisé.

Pour être plus précis, la fonction DoAppend vérifie les filtres puis appelle une fonction Append qui prend en paramètre un LoggingEvent :

abstract protected void Append(LoggingEvent loggingEvent);

Chaque appender, héritant forcément de la classe AppenderSkeleton, devra donc implémenter cette méthode abstraite. C'est cette méthode qui loggera l'événement suivant l'appender utilisé. C'est donc sur l'implémentation de cette méthode qui nous porterons nos efforts lors du développement de notre propre appender.

Certains appenders sont bufferisés (ils dérivent de la classe abstract BufferingAppenderSkeleton, qui elle-même dérive de la classe abstraite AppenderSkeleton). Cela signifie que tant que la taille des messages à logger n'aura pas atteint la taille définie dans le fichier de configuration, alors ces messages seront ajoutés dans un buffer. Quand la taille définie aura été atteinte, tous les messages seront loggés d'un coup.

Pour ces appenders, c'est la fonction SendBuffer qui est chargé de logger les événements :

abstract protected void SendBuffer(LoggingEvent[] events);

Quant à elle, la fonction Append est chargée d'ajouter les événements au buffer et d'appeler la fonction SendBuffer quand le buffer atteint la taille limite.

Chaque appender a ses propres propriétés. Par exemple, l'appender SmtpAppender possède entre autres les propriétés From, To, Subject. On définit, si on le souahite, la valeur de ces propriétés dans le fichier de configuration de log4net. Pour le SmtpAppender, la configuration ressemble à :

<to value="destinataire@mail.com" />
<from value="expediteur@mail.com" />
<subject value="Alerte, tout a pété" />

Ces propriétés étant définies dans le code source de l'appender, les éléments xml associés porteront donc le même nom.

public string To 
{
	get { return m_to; }
	set { m_to = value; }
}
public string From 
{
	get { return m_from; }
	set { m_from = value; }
}
public string Subject 
{
	get { return m_subject; }
	set { m_subject = value; }
}

Log4net utilise la réflexion pour associer une valeur aux propriétés de l'appender à partir des éléments xml du fichier de configuration.

Pour ceux que cela intéresse, la fonction en charge de cette tâche est : log4net.Repository.Hierarchy.XmlHierarchyConfigurator.SetParameter

Ainsi, si vous voulez définir une propriété lors du développement de votre appender, il suffira de déclarer la propriété et de créer le noeud xml associé dans le fichier de configuration :

public int MyProperty 
{
	get { return m_myproperty; }
	set { m_myproperty = value; }
}

<myProperty value="12" />

Vous savez maintenant tout ce qu'il faut pour développer votre propre appender.

Nous allons maintenant mettre cela en pratique à travers différents exemples.

Comme dit précédemment, le sujet du mail est défini en dur dans le fichier de configuration de log4net. Cela est assez limitant et il serait par exemple utile d'avoir le niveau du log dans le sujet du mail.

Cela est très facilement faisable en utilisant un Layout plutôt qu'une simple chaîne de caractères pour le sujet du mail. La modification se fait à 2 niveaux : au niveau de l'appender lui-même et au niveau du fichier de configuration.

Au niveau de l'appender, on définit une propriété SubjectLayout de type ILayout :

public ILayout LayoutSubject { get; set; }

Au niveau du fichier de configuration:

<layoutSubject type="log4net.Layout.PatternLayout,log4net">
   <conversionPattern value="[%level] Log from my app" />
</layoutSubject>

Avec une telle configuration, le mail reçu lors d'une erreur aura le sujet suivant : [ERROR] Log from my app.

Au moment de l'envoi du mail, il reste à formater le sujet :

var subjectWriter = new StringWriter(System.Globalization.CultureInfo.InvariantCulture);

// On formate le sujet
LayoutSubject.Format(subjectWriter, loggingEvent);

Notez le fait que la propriété au niveau de l'appender porte le même nom que le noeud XML au niveau du fichier de configuration comme expliqué précédemment.

Remarquez aussi que je n'ai pas nommé la propriété « subject » comme c'est le cas pour le SmtpAppender par défaut. En effet, l'appender SmtpAppender possède une propriété « subject » de type chaîne de caractères. Le fait de la surcharger provoque l'erreur suivante lors du chargement de l'appender :

System.Reflection.AmbiguousMatchException : Correspondance ambiguë trouvée

Pour cela, on va juste ajouter une propriété « IsHtmlFormat» de type booléen.

Au niveau de l'appender :

public bool IsHtmlFormat { get; set; }

Au niveau du fichier de configuration:

<isHtmlFormat value="true" />

Il reste à spécifier le format du mail lors de sa création. Cela se fait via la propriété IsBodyHtml de l'objet MailMessage.

var mailMessage = new MailMessage
{
	Body = messageBody,
	From = new MailAddress(From),
	Subject = messageSubject,
	Priority = Priority,
	IsBodyHtml = IsHtmlFormat
};

Dernier petit détail : lors du formatage du corps du mail, si on utilise le format HTML, il faut remplacer les sauts de ligne par la chaîne de caractères « <br/> ».

if (IsHtmlFormat)
{
	messageBody = messageBody.Replace(Environment.NewLine, "<br/>");
}

L'idée est de définir une propriété qui spécifiera les fichiers à joindre au mail. Le nom des fichiers à joindre seront stockés dans une chaîne de caractères, séparés par un ' ;'. Pour cela, on va créer une propriété « Attachment ».

Au niveau de l'appender :

public string Attachment { get; set; }

Au niveau du fichier de configuration:

<attachment value="aFile.txt;C:\Temp\anOtherFile.txt" />

Il reste maintenant à joindre les fichiers au mail. Pour chaque fichier :

• On regarde si le chemin défini dans le fichier de config est absolu ou non.
• Si non, on récupère le chemin absolu (en différenciant le cas d'une application web avec une application non web)
• On attache le fichier au mail

// on ajoute la ou les pièce(s) jointe(s)
if (!string.IsNullOrEmpty(Attachment))
{
    var attachments = Attachment.Split(';');
    foreach (var attach in attachments)
    {
        if (!string.IsNullOrEmpty(attach.Trim()))
        {
            var path = attach.Trim();
            try
            {
                var context = HttpContext.Current;
                if (context == null) //context non web
                {
                    //on teste s'il s'agit d'un chemin absolu ou non
                    if(!Path.IsPathRooted(path))
                    {
                        path = Directory.GetCurrentDirectory() + "\\" + path;
                    }

                    if (File.Exists(path))
                    {
                        //si le fichier spécifié existe bien, on l'ajoute en pièce jointe au mail
                        AttachFile(mailMessage, path);
                    }
                    else
                    {
                        // Sinon, on écrit dans le corps du mail que le fichier n'a pas été trouvé
                        mailMessage.Body += IsHtmlFormat ? "<br/>" : Environment.NewLine;
                        mailMessage.Body += IsHtmlFormat ? "<br/>" : Environment.NewLine;
                        mailMessage.Body += "Fichier non trouvé: " + attach;
                    }
                }
                else //context web
                {
                    //on teste s'il s'agit d'un chemin absolu ou non
                    if (!Path.IsPathRooted(path))
                    {
                        path = context.Server.MapPath(path);
                    }

                    if (File.Exists(path))
                    {
                        //si le fichier spécifié existe bien, on l'ajoute en pièce jointe au mail
                        AttachFile(mailMessage, path);
                    }
                    else
                    {
                        // Sinon, on écrit dans le corps du mail que le fichier n'a pas été trouvé
                        mailMessage.Body += IsHtmlFormat ? "<br/>" : Environment.NewLine;
                        mailMessage.Body += IsHtmlFormat ? "<br/>" : Environment.NewLine;
                        mailMessage.Body += "Fichier non trouvé: " + attach;
                    }
                }
            }
            catch (Exception ex)
            {
		// En cas d'erreur, on précise dans le corps du mail que le fichier n'a pu être joint
		mailMessage.Body += IsHtmlFormat ? "<br/>" : Environment.NewLine;
		mailMessage.Body += IsHtmlFormat ? "<br/>" : Environment.NewLine;
		mailMessage.Body += string.Format("<b>Erreur lors de l'ajout de la piece jointe: {0}</b>", attach);
		
		// On logge l'erreur avec le logger interne de log4net
		LogLog.Error(string.Format("Erreur lors de la pièe jointe: {0} (path: {1})", attach, path), ex);
            }
        }
    }
}

Veuillez noter l'utilisation de l'instruction LogLog.Error dans le catch. LogLog est une classe sealed du namespace Log4net.Util. Elle permet de logger les erreurs de log4net lorsque les logs internes sont activés (plus de détails ici).

La fonction pour joindre le fichier au mail est :

private void AttachFile(MailMessage mailMessage, string path)
{
	var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
	mailMessage.Attachments.Add(new Attachment(stream, Path.GetFileName(Attachment)));
}

L'appender SmtpAppender est un appender bufferisé. Cela signifie que l'on peut définir une taille minimum pour le message à envoyer. Tant que la taille du message est inférieure à la taille définie, les messages à logger sont mis bout à bout.

Dans notre cas, étant donné que l'on a créé un sujet dynamique, cette notion de buffer perd son intérêt. Imaginons le cas suivant : on a défini le sujet du mail de façon à y intégrer le niveau de l'événement à logger. Un certain nombre d'erreurs se produisent sans pour autant dépasser la taille du buffer. Suite à cela, un événement de niveau INFO se produit et fait dépasser la taille du buffer. Le mail est alors envoyé avec le niveau INFO dans le sujet alors que la plupart des événements contenus dans le corps du mail sont des événements de type ERROR. Pour cette raison, on va désactiver la partie bufferisée de l'appender SmtpAppender.

Pour cela, et contrairement à un appender bufférisé classique, on loggera l'événement dans la fonction Append et non dans la fonction SendBuffer.

Pour terminer, voilà un exemple de fichier de configuration pour utiliser cet appender :

<appender name="CustomSmtpAppender" type="DVP.log4net.Appender.NonBufferedSmtpAppenderWithSubjectLayoutAndAttachment, DVP.log4net">
    <to value="destinataire@mail.com" />
    <from value="expediteur@mail.com" />
    <layoutSubject type="log4net.Layout.PatternLayout,log4net">
      <conversionPattern value="[%level] Log from WebApp" />
    </layoutSubject>
    <smtpHost value="smtp.free.fr" />
    <threshold value="DEBUG" />
    <attachment value="Log/Log.txt" />
    <isHtmlFormat value="true" />
    <layout type="log4net.Layout.PatternLayout,log4net">
      <conversionPattern value="LEVEL: %level %newlineDATE: %date  %newlineLOGGER: %logger %newline%newline%message" />
    </layout>
  </appender>