.net Core 6 Logging To Database

INFLUENCESMAG.ORG

5 min read

·

Jun 03, 2024

31

Share

Enregistrer les journaux dans une base de données avec .NET Core 6

La journalisation est un élément crucial du développement d'applications robustes et fiables. En enregistrant les événements et les erreurs, vous pouvez déboguer efficacement votre application, analyser son comportement et identifier les problèmes potentiels. .NET Core 6 offre une variété d'options de journalisation, et l'enregistrement dans une base de données est une approche courante pour une persistance à long terme et une analyse approfondie.

Pourquoi enregistrer dans une base de données ?

L'enregistrement dans une base de données présente plusieurs avantages :

• Persistance : Les journaux sont stockés de manière permanente, vous permettant de les consulter et de les analyser à tout moment.
• Recherche et filtrage : Les bases de données offrent des fonctionnalités de recherche et de filtrage avancées, vous permettant de facilement identifier les journaux pertinents.
• Analyse : Vous pouvez utiliser des outils d'analyse de données pour extraire des informations précieuses de vos journaux.
• Intégration : Les bases de données s'intègrent facilement avec d'autres outils et systèmes.

Mise en œuvre de la journalisation dans une base de données

Voici les étapes pour configurer la journalisation dans une base de données avec .NET Core 6 :

1. Installer le package NuGet:

   Install-Package Microsoft.Extensions.Logging.EntityFrameworkCore
   

2. Configurer le fournisseur de journalisation dans le fichier Program.cs :

   using Microsoft.EntityFrameworkCore;
   using Microsoft.Extensions.Logging;
   
   // ...
   
   builder.Services.AddDbContext(options =>
       options.UseSqlServer("YourConnectionString")
               .UseLoggerFactory(LoggerFactory.Create(builder =>
                   builder.AddEntityFramework()
                          .AddConsole()
                          .AddDebug()
                          .AddProvider()
               )));
   

   Remarque: Remplacez YourDbContext et YourConnectionString par les valeurs appropriées pour votre application.

3. Créer une table de journalisation dans votre base de données :

   CREATE TABLE Logs (
       Id INT IDENTITY(1,1) PRIMARY KEY,
       Timestamp DATETIME2 NOT NULL,
       LogLevel VARCHAR(20) NOT NULL,
       Message VARCHAR(MAX) NOT NULL,
       Exception VARCHAR(MAX)
   );
   

4. Créer un fournisseur de journalisation de base de données personnalisé (DbLoggerProvider) :

   public class DbLoggerProvider : ILoggerProvider
   {
       private readonly DbContext _context;
   
       public DbLoggerProvider(DbContext context)
       {
           _context = context;
       }
   
       public ILogger CreateLogger(string categoryName)
       {
           return new DbLogger(_context, categoryName);
       }
   
       public void Dispose()
       {
           // Dispose of any resources here.
       }
   }
   
   public class DbLogger : ILogger
   {
       private readonly DbContext _context;
       private readonly string _categoryName;
   
       public DbLogger(DbContext context, string categoryName)
       {
           _context = context;
           _categoryName = categoryName;
       }
   
       public IDisposable BeginScope(TState state)
       {
           return null;
       }
   
       public bool IsEnabled(LogLevel logLevel)
       {
           return true;
       }
   
       public void Log(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func formatter)
       {
           var message = formatter(state, exception);
           var logEntry = new LogEntry {
               Timestamp = DateTime.UtcNow,
               LogLevel = logLevel.ToString(),
               Message = message,
               Exception = exception?.ToString()
           };
   
           _context.Logs.Add(logEntry);
           _context.SaveChanges();
       }
   }
   
   public class LogEntry
   {
       public int Id { get; set; }
       public DateTime Timestamp { get; set; }
       public string LogLevel { get; set; }
       public string Message { get; set; }
       public string Exception { get; set; }
   }
   

5. Utiliser la journalisation dans votre code :

   public class MyService
   {
       private readonly ILogger _logger;
   
       public MyService(ILogger logger)
       {
           _logger = logger;
       }
   
       public void DoSomething()
       {
           try
           {
               // ... code qui peut générer des erreurs
           }
           catch (Exception ex)
           {
               _logger.LogError(ex, "Une erreur s'est produite.");
           }
       }
   }
   

Conclusion

L'enregistrement dans une base de données est un moyen efficace de gérer les journaux de votre application .NET Core 6. En suivant ces étapes, vous pouvez configurer la journalisation dans une base de données et obtenir des informations précieuses sur le comportement de votre application.