La gestion des journaux est une fonctionnalité essentielle pour le débogage, la surveillance et l'audit des applications. NLog est une bibliothèque de journalisation flexible et gratuite pour diverses plateformes .NET, y compris ASP.NET Core. Ce guide détaille comment intégrer et configurer NLog pour enregistrer les messages dans des fichiers locaux et une base de données SQL Server.
1. Installation des dépendances NuGet
Commencez par ajouter les packages NuGet nécessaires à votre projet ASP.NET Core. Ouvrez le gestionnaire de packages NuGet ou utilisez la console du gestionnaire de packages :
NLog.Web.AspNetCore: Permet l'intégration d'NLog avec le pipeline de journalisation ASP.NET Core.System.Data.SqlClient: Nécessaire pour la cible de journalisation SQL Server.
2. Configuraton d'NLog via un fichier XML
Créez un dossier nommé par exemple ParametresNLog à la racine de votre projet et ajoutez-y un fichier nommé NLog.config. Assurez-vous de définir la propriété "Copier dans le répertoire de sortie" sur "Toujours copier" pour ce fichier via les propriétés de Visual Studio.
Voici un exemple de configuration NLog.config qui définit des cibles pour les journaux d'erreurs, de traces et une base de données SQL Server :
<?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"
xsi:schemaLocation="http://www.nlog-project.org/schemas/NLog.xsd NLog.xsd"
autoReload="true"
throwExceptions="false"
internalLogLevel="Off" internalLogFile="c:\temp\nlog-internal.log">
<variable name="parametrePerso" value="valeurTest"/>
<targets>
<!-- Cible pour les erreurs critiques et non gérées, sauvegardées dans des fichiers -->
<target name="fichier_erreurs" xsi:type="File" maxArchiveFiles="30" encoding="utf-8"
fileName="${basedir}/LogFiles/${date:yyyyMMdd}_Erreurs.TXT"
archiveFileName="${basedir}/LogFiles/${date:yyyyMMdd}_Erreurs.{#}.TXT"
archiveDateFormat="yyyyMMdd"
archiveAboveSize="104857600"
archiveNumbering="Sequence"
layout="${date:yyyy-MM-dd HH\:mm\:ss.fff} | ${level:uppercase=true} | ${message} ${onexception:${exception:format=tostring}${newline}${stacktrace}}" />
<!-- Cible pour les informations de trace détaillées, sauvegardées dans des fichiers -->
<target name="fichier_traces" xsi:type="File" maxArchiveFiles="30" encoding="utf-8"
fileName="${basedir}/LogFiles/${date:yyyyMMdd}_Traces.TXT"
archiveFileName="${basedir}/LogFiles/${date:yyyyMMdd}_Traces.{#}.TXT"
archiveDateFormat="yyyyMMdd"
archiveAboveSize="104857600"
archiveNumbering="Sequence"
layout="${date:yyyy-MM-dd HH\:mm\:ss.fff} | ${level:uppercase=true} | ${message}" />
<!-- Cible pour le stockage des journaux dans une base de données SQL Server -->
<target name="base_de_donnees" xsi:type="Database"
dbProvider="System.Data.SqlClient.SqlConnection,System.Data.SqlClient"
connectionString="Data Source=MONSERVEUR;Initial Catalog=MaBaseLogs;Persist Security Info=True;User ID=utilisateurBD;Password=monMotDePasse"
commandText="INSERT INTO AppLogs (NomAppli, Horodatage, Niveau, MessageJournal, NomLogger, SiteAppel, DetailsException) VALUES (@nomAppli, @horodatage, @niveau, @messageJournal, @nomLogger, @siteAppel, @detailsException);">
<parameter name="@nomAppli" layout="MonAppliAspNetCore" />
<parameter name="@horodatage" layout="${date}" />
<parameter name="@niveau" layout="${level}" />
<parameter name="@messageJournal" layout="${message}" />
<parameter name="@nomLogger" layout="${logger}" />
<parameter name="@siteAppel" layout="${callsite:filename=true}" />
<parameter name="@detailsException" layout="${exception:tostring}" />
</target>
</targets>
<rules>
<!-- Règle pour enregistrer les traces et informations d'avertissement dans le fichier de traces -->
<logger name="*" minlevel="Trace" maxlevel="Warn" writeTo="fichier_traces" />
<!-- Règle pour enregistrer les erreurs et les critiques dans le fichier d'erreurs -->
<logger name="*" minlevel="Error" writeTo="fichier_erreurs" />
<!-- Règle pour enregistrer les informations (Info) et les niveaux supérieurs dans la base de données -->
<logger name="*" minlevel="Info" writeTo="base_de_donnees" />
</rules>
</nlog>
Note importante : N'oubliez pas de modifier la chaîne de connexion (connectionString) dans la cible base_de_donnees pour qu'elle corresponde à votre environnement SQL Server.
3. Création de la table de journalisation SQL Server
Exécutez le script SQL suivant sur votre serveur SQL Server pour créer la base de données (si nécessaire) et la table AppLogs qui stockera les entrées de journal.
USE [MaBaseLogs] -- Remplacez par le nom de votre base de données
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[AppLogs](
[Id] [int] IDENTITY(1,1) NOT NULL,
[NomAppli] [nvarchar](50) NOT NULL,
[Horodatage] [datetime] NOT NULL,
[Niveau] [nvarchar](50) NOT NULL,
[MessageJournal] [nvarchar](max) NOT NULL,
[NomLogger] [nvarchar](250) NULL,
[SiteAppel] [nvarchar](max) NULL,
[DetailsException] [nvarchar](max) NULL,
CONSTRAINT [PK_AppLogs] PRIMARY KEY CLUSTERED
(
[Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
4. Intégration d'NLog dans Program.cs
Pour activer NLog dans votre application ASP.NET Core, modifiez le fichier Program.cs afin d'inclure la configuration NLog dans le pipeline de journalisation :
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using NLog.Web;
// Configuration du logger NLog
var logger = NLog.Web.NLogBuilder.ConfigureNLog("ParametresNLog/NLog.config");
try
{
var builder = WebApplication.CreateBuilder(args);
// Supprimer les fournisseurs de journalisation par défaut et ajouter NLog
builder.Logging.ClearProviders();
builder.Logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace); // Définir le niveau minimum de journalisation global
builder.Host.UseNLog(); // Utiliser NLog pour la journalisation
// Ajouter les services au conteneur.
builder.Services.AddControllersWithViews();
var app = builder.Build();
// Configurer le pipeline de requêtes HTTP.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();
}
catch (Exception exception)
{
// Capture des exceptions de démarrage d'application
logger.Error(exception, "L'application s'est arrêtée en raison d'une exception non gérée au démarrage.");
throw;
}
finally
{
// S'assurer que NLog est arrêté correctement à la fermeture de l'application
NLog.LogManager.Shutdown();
}
5. Utilisation d'NLog dans un contrôleur
Vous pouvez injecter ILogger<T> ou ILoggerFactory dans vos contrôleurs ou services pour enregistrer des messages. Voici un exemple d'implémentation dans un contrôleur MVC :
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
namespace MonAppliLogs.Controllers
{
public class JournalisationController : Controller
{
private readonly ILogger<JournalisationController> _journaliseurApplicatif;
private readonly ILoggerFactory _fabriqueJournaliseur;
public JournalisationController(ILogger<JournalisationController> logger, ILoggerFactory loggerFactory)
{
_journaliseurApplicatif = logger;
_fabriqueJournaliseur = loggerFactory;
// Démonstration de l'utilisation d'un logger créé par la fabrique
ILogger<JournalisationController> loggerSecondaire = _fabriqueJournaliseur.CreateLogger<JournalisationController>();
_journaliseurApplicatif.LogInformation($"{this.GetType().Name}: Le contrôleur a été initialisé.");
loggerSecondaire.LogInformation($"Logger secondaire pour {this.GetType().Name} a été utilisé lors de la construction.");
}
public IActionResult VisualiserLogs()
{
_journaliseurApplicatif.LogInformation("La méthode VisualiserLogs a été exécutée.");
// Utilisation de la fabrique pour créer un logger au sein d'une action
var loggerDynamique = _fabriqueJournaliseur.CreateLogger<JournalisationController>();
loggerDynamique.LogDebug("Une entrée de journal de débogage créée via la fabrique dans VisualiserLogs.");
return View(); // Peut retourner une vue ou un message simple
}
public IActionResult TesterNiveaux()
{
_journaliseurApplicatif.LogTrace("Ceci est un message de TRACE détaillé.");
_journaliseurApplicatif.LogDebug("Ceci est un message de DÉBOGAGE.");
_journaliseurApplicatif.LogInformation("Ceci est un message d'INFORMATION.");
_journaliseurApplicatif.LogWarning("Ceci est un message d'AVERTISSEMENT.");
_journaliseurApplicatif.LogError("Ceci est un message d'ERREUR potentielle.");
_journaliseurApplicatif.LogCritical("Ceci est un message CRITIQUE ! Une défaillance majeure.");
return Json(new { succes = true, message = "Tous les niveaux de journalisation ont été testés." });
}
}
}
6. Vérification des journaux
Après avoir exécuté votre application et navigué vers les actions /Journalisation/VisualiserLogs et /Journalisation/TesterNiveaux, vous devriez pouvoir observer les résultats :
- Des fichiers de log (
*_Erreurs.TXTet*_Traces.TXT) générés dans le dossierDebug\netX.0\LogFiles(où X est la version de votre framework .NET). - Des entrées dans la table
AppLogsde votre base de données SQL Server, contenant les messages de niveau "Info" et supérieur.