Roamba Windlassida Epaphras
Roamba Epaphras
#asp-net#dotnet#logger#nlog#journalisation#debugging#production

ASP.NET : Comment créer un fichier de journalisation ou un logger?

Le fichier de journalisation ou un logger enregistre chronologiquement les événements exécutés sur notre application. Il permet de comprendre et de déboguer rapidement notre application en production.

Roamba Epaphras, développeur Full-Stack à Abidjan, Côte d'Ivoire Roamba Windlassida Epaphras
ASP.NET : Comment créer un fichier de journalisation ou un logger?

Après la création de notre crud dans l'article "CRUD ASP.NET Core MVC avec MYSQL", nous ajouterons un fichier de journalisation ou un logger pour suivre l'état de notre application en production.

C'est quoi un fichier de journalisation ou logger?

Le fichier de journalisation ou un logger enregistre chronologiquement les événements exécutés sur notre application. Il permet de comprendre et de déboguer rapidement notre application en production en cas de bug ou erreur.

ASP.net core propose des fournisseurs de journalisation grâce à son hôte générique au niveau des éléments suivants:

Les fournisseurs de journaux de ASP.core peuvent être appelés fournisseurs de journalisation intégrés.

Configuration de base

Avant de créer un fichier de journalisation, il faut effectuer une configuration.

La configuration de la journalisation est généralement fournie par la section Logging des fichiers appsettings.{ENVIRONMENT}.json, où l'espace réservé {ENVIRONMENT} correspond à l'environnement. Le fichier appsettings.Development.json suivant est généré par défaut dans le projet ASP.NET Core :

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  }
}

La propriété Logging peut avoir des propriétés LogLevel et des propriétés de fournisseur de journaux.

Le logLevel est constitué d'une catégorie à gauche et d'un niveau de log à droite.

Niveaux de journalisation

Il est important de comprendre comment le niveau de log fonctionne.

La propriété LogLevel spécifie le niveau de journalisation minimal pour les catégories sélectionnées. Dans le code JSON précédent, les niveaux de journalisation Information et Warning sont spécifiés. LogLevel indique le niveau de gravité du journal, qui peut varier de 0 à 6 :

Trace = 0, Debug = 1, Information = 2, Warning = 3, Error = 4, Critical = 5 et None = 6.

ASP.NET niveau de log ou log level

NB: Pour en savoir plus sur la journalisation dotnet voici le lien de la page officiel avec plus de détail en fonction de votre version de dotnet:

https://learn.microsoft.com/fr-fr/aspnet/core/fundamentals/logging/?view=aspnetcore-7.0

Maintenant débutons le code 👍

Nlog avec .NET core

Nous utiliserons un fournisseur de journalisation tiers (Nlog) qui nous permettra d'avoir notre fichier de journalisation.

Installation du package NLog

Ajoutons et installons le package nlog.

NLog.Web.AspNetCore

Installation NLog

Configuration du fichier NLog

Ajoutons un fichier de configuration propre à nlog

À la racine du projet créons un fichier nlog.config

Création du fichier nlog.config

Ajoutons les éléments suivants dans notre fichier :

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <targets>
    <target name="allfile" xsi:type="File"
   fileName="c:\\${shortdate}_logfile.txt"/>
  </targets>
  <rules>
      <logger name="*" minlevel="Info" writeTo="allfile" />
      <logger name="System.*" finalMinLevel="Warn" />
      <logger name="Microsoft.*" finalMinLevel="Warn" />
      <logger name="Microsoft.Hosting.Lifetime*" finalMinLevel="Info" />
  </rules>
  </nlog>

L'élément &lt;target&gt; nous permet de générer un fichier avec les informations de journalisation dans le fichier correspondant.

Configuration dans Program.cs

Dans notre fichier Program.cs ajoutons nlog :

public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args).ConfigureLogging((hostingContext, logging) =>
            {
                logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
                logging.AddNLog();
            }).ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });

Configuration dans Startup.cs

Dans notre fichier Startup aussi ajoutons l'élément suivant :

LogManager.LoadConfiguration(string.Concat(Directory.GetCurrentDirectory(),
"/nlog.config"));

Configuration Startup

Test en développement

Démarrons à nouveau notre solution et observons la création de fichier de journalisation ou log.

Après le démarrage, vous devriez voir un fichier de log généré automatiquement avec les événements de votre application.

Configuration pour la production

Adaptation du chemin pour Linux

Configurons notre fichier nlog.config pour la production sur un serveur linux.

Changeons juste notre path ou chemin avec le filename de notre serveur en production :

<target name="allfile" xsi:type="File"
   fileName="${basedir}/logs/${shortdate}_logfile.txt"/>

Déploiement en production

Faisons la mise à jour en production sur notre serveur linux.

Après la mise à jour nous démarrons notre service :

epa@localhost:/var/log$ sudo systemctl restart crud-mvc.service
epa@localhost:/var/log$ sudo systemctl status crud-mvc.service

Observons maintenant dans le fichier de notre projet nous avons le dossier logs avec notre fichier de journalisation à l'intérieur.

Fichiers de log générés

Utilisation du logger dans le code

Voici comment utiliser le logger dans vos contrôleurs :

public class ContactController : Controller
{
    private readonly ILogger<ContactController> _logger;
    private readonly DataContext _db;
    public ContactController(ILogger<ContactController> logger, DataContext db)
    {
        _db = db;
        _logger = logger;
    }
    public async Task<IActionResult> Index()
    {
        _logger.LogInformation("Accès à la page d'index des contacts");
        try
        {
            var result = await _db.Contacts.ToListAsync();
            return View(result);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Erreur lors de la récupération des contacts");
            return View(new List<Contact>());
        }
    }
    [HttpPost]
    public async Task<IActionResult> Create(Contact contact)
    {
        if (ModelState.IsValid)
        {
            try
            {
                _db.Contacts.Add(contact);
                await _db.SaveChangesAsync();
                _logger.LogInformation("Contact créé avec succès : {ContactId}", contact.Id);
                TempData["success"] = "Création effectuée avec succès";
                return RedirectToAction("Index");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Erreur lors de la création du contact");
                ModelState.AddModelError("", "Erreur lors de la création");
            }
        }
        return View(contact);
    }
}

Avantages du logging avec NLog

🔸 Avantages principaux :

  • Traçabilité complète : Enregistrement de toutes les actions importantes
  • Debugging facilité : Identification rapide des erreurs en production
  • Monitoring : Surveillance continue de l'application
  • Audit : Historique des opérations effectuées
  • Performance : Identification des goulots d'étranglement

🔸 Types de logs recommandés :

  • Information : Actions importantes (connexion utilisateur, création d'entité)
  • Warning : Situations suspectes mais non bloquantes
  • Error : Erreurs gérées avec contexte
  • Critical : Erreurs critiques nécessitant une intervention immédiate

Bonnes pratiques

  1. Structurer vos messages : Utilisez des messages clairs et contextuels
  2. Éviter les logs excessifs : Ne loggez pas chaque opération triviale
  3. Inclure le contexte : Ajoutez les IDs et données pertinentes
  4. Gérer la rotation : Configurez la rotation des fichiers pour éviter les gros volumes
  5. Sécurité : Ne loggez jamais de données sensibles (mots de passe, tokens)

Conclusion

Nous savons maintenant ajouter un fichier de journalisation dans nos projets .NET Core. Le logging est essentiel pour :

  • Maintenir la qualité de l'application en production
  • Diagnostiquer rapidement les problèmes
  • Monitorer les performances et l'utilisation
  • Assurer la traçabilité des opérations

Cette implémentation avec NLog vous donne une base solide pour une gestion professionnelle des logs dans vos applications ASP.NET Core.

#AspNet #DotNet #Logger #NLog #Journalisation #Production #Debugging