Partager via

Implémenter un fournisseur de journalisation personnalisé dans .NET

Il existe de nombreux fournisseurs de journalisation disponibles pour les besoins courants de journalisation. Toutefois, vous devrez peut-être implémenter un fournisseur personnalisé ILoggerProvider lorsque l’un des fournisseurs disponibles ne répond pas aux besoins de votre application. Dans cet article, vous allez apprendre à implémenter un fournisseur de journalisation personnalisé qui peut être utilisé pour coloriser les journaux dans la console.

Conseil / Astuce

L’exemple de code source du fournisseur de journalisation personnalisé est disponible dans le dépôt GitHub docs.

Exemple de configuration d’enregistreur d’événements personnalisé

L’exemple d’enregistreur d’événements crée différentes entrées de console de couleur par niveau de journal et ID d’événement à l’aide du type de configuration suivant :

using Microsoft.Extensions.Logging;

public sealed class ColorConsoleLoggerConfiguration
{
    public int EventId { get; set; }

    public Dictionary<LogLevel, ConsoleColor> LogLevelToColorMap { get; set; } = new()
    {
        [LogLevel.Information] = ConsoleColor.Green
    };
}

Le code précédent définit la couleur par défaut du Information niveau sur Green. La EventId valeur est implicitement 0.

Créer l’enregistreur d’événements personnalisé

L’extrait de code suivant montre l’implémentation ILogger :

using Microsoft.Extensions.Logging;

public sealed class ColorConsoleLogger(
    string name,
    Func<ColorConsoleLoggerConfiguration> getCurrentConfig) : ILogger
{
    public IDisposable? BeginScope<TState>(TState state)
        where TState : notnull => default!;

    public bool IsEnabled(LogLevel logLevel) =>
        getCurrentConfig().LogLevelToColorMap.ContainsKey(logLevel);

    public void Log<TState>(
        LogLevel logLevel,
        EventId eventId,
        TState state,
        Exception? exception,
        Func<TState, Exception?, string> formatter)
    {
        if (!IsEnabled(logLevel))
        {
            return;
        }

        ColorConsoleLoggerConfiguration config = getCurrentConfig();
        if (config.EventId == 0 || config.EventId == eventId.Id)
        {
            ConsoleColor originalColor = Console.ForegroundColor;

            Console.ForegroundColor = config.LogLevelToColorMap[logLevel];
            Console.WriteLine($"[{eventId.Id,2}: {logLevel,-12}]");
            
            Console.ForegroundColor = originalColor;
            Console.Write($"     {name} - ");

            Console.ForegroundColor = config.LogLevelToColorMap[logLevel];
            Console.Write($"{formatter(state, exception)}");
            
            Console.ForegroundColor = originalColor;
            Console.WriteLine();
        }
    }
}

Chaque instance d’enregistreur d’événements est instanciée en passant un nom de catégorie, qui est généralement le type où l’enregistreur d’événements est créé. La IsEnabled méthode vérifie getCurrentConfig().LogLevelToColorMap.ContainsKey(logLevel) si le niveau de journal demandé est activé (autrement dit, dans le dictionnaire des niveaux de journalisation de la configuration).

Il est recommandé d’appeler ILogger.IsEnabled au sein des implémentations de ILogger.Log, car Log peut être appelée par n’importe quel consommateur, et il n'y a aucune garantie que cela ait été vérifié précédemment. La méthode IsEnabled doit être très rapide dans la plupart des implémentations.

if (!IsEnabled(logLevel))
{
    return;
}

L’enregistreur d’événements est instancié avec le name et un Func<ColorConsoleLoggerConfiguration> qui retourne la configuration actuelle.

Important

L’implémentation ILogger.Log vérifie si la valeur config.EventId est définie. Quand config.EventId n’est pas défini ou lorsqu’il correspond exactement à logEntry.EventId, l'enregistreur enregistre en couleur.

Fournisseur d’enregistreurs d’événements personnalisés

L’objet ILoggerProvider est chargé de créer des instances d’enregistreur d’événements. Il n’est pas nécessaire de créer une instance d’enregistreur d’événements par catégorie, mais il est logique pour certains enregistreurs d’événements, tels que NLog ou log4net. Cette stratégie vous permet de choisir différentes cibles de sortie de journalisation par catégorie, comme dans l’exemple suivant :

using System.Collections.Concurrent;
using System.Runtime.Versioning;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

[UnsupportedOSPlatform("browser")]
[ProviderAlias("ColorConsole")]
public sealed class ColorConsoleLoggerProvider : ILoggerProvider
{
    private readonly IDisposable? _onChangeToken;
    private ColorConsoleLoggerConfiguration _currentConfig;
    private readonly ConcurrentDictionary<string, ColorConsoleLogger> _loggers =
        new(StringComparer.OrdinalIgnoreCase);

    public ColorConsoleLoggerProvider(
        IOptionsMonitor<ColorConsoleLoggerConfiguration> config)
    {
        _currentConfig = config.CurrentValue;
        _onChangeToken = config.OnChange(updatedConfig => _currentConfig = updatedConfig);
    }

    public ILogger CreateLogger(string categoryName) =>
        _loggers.GetOrAdd(categoryName, name => new ColorConsoleLogger(name, GetCurrentConfig));

    private ColorConsoleLoggerConfiguration GetCurrentConfig() => _currentConfig;

    public void Dispose()
    {
        _loggers.Clear();
        _onChangeToken?.Dispose();
    }
}

Dans le code précédent, CreateLogger(String) crée une instance unique du ColorConsoleLogger par nom de catégorie et la stocke dans le ConcurrentDictionary<TKey,TValue>.

La ColorConsoleLoggerProvider classe est décorée avec deux attributs :

[UnsupportedOSPlatform("browser")]
[ProviderAlias("ColorConsole")]
public sealed class ColorConsoleLoggerProvider : ILoggerProvider

La configuration peut être spécifiée avec n’importe quel fournisseur de configuration valide. Considérez le fichier appsettings.json suivant :

{
    "Logging": {
        "ColorConsole": {
            "LogLevelToColorMap": {
                "Information": "DarkGreen",
                "Warning": "Cyan",
                "Error": "Red"
            }
        }
    }
}

Le fichier appsettings.json spécifie que la couleur du niveau du Information journal est DarkGreen, qui remplace la valeur par défaut définie dans l’objet ColorConsoleLoggerConfiguration .

Utilisation et inscription de l’enregistreur d’événements personnalisé

Par convention, les services sont inscrits pour l’injection de dépendances dans le cadre de la routine de démarrage d’une application. Dans cet exemple, le service de journalisation est inscrit directement depuis le fichier Program.cs.

Pour ajouter le fournisseur de journalisation personnalisé et le logger correspondant, ajoutez un ILoggerProvider en appelant une méthode d'extension personnalisée, AddColorConsoleLogger, sur le ILoggingBuilder de la propriété IHostApplicationBuilder.Logging.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);

builder.Logging.ClearProviders();
builder.Logging.AddColorConsoleLogger(configuration =>
{
    // Replace value of "Cyan" from appsettings.json.
    configuration.LogLevelToColorMap[LogLevel.Warning]
        = ConsoleColor.DarkCyan;
    // Replace value of "Red" from appsettings.json.
    configuration.LogLevelToColorMap[LogLevel.Error]
        = ConsoleColor.DarkRed;
});

using IHost host = builder.Build();

ILogger<Program> logger = host.Services.GetRequiredService<ILogger<Program>>();

logger.LogDebug(1, "Does this line get hit?");    // Not logged
logger.LogInformation(3, "Nothing to see here."); // Logs in ConsoleColor.DarkGreen
logger.LogWarning(5, "Warning... that was odd."); // Logs in ConsoleColor.DarkCyan
logger.LogError(7, "Oops, there was an error.");  // Logs in ConsoleColor.DarkRed
logger.LogTrace(5, "== 120.");                    // Not logged

await host.RunAsync();

Conventionnellement, les méthodes d’extension sur ILoggingBuilder sont utilisées pour enregistrer le fournisseur personnalisé :

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Configuration;

public static class ColorConsoleLoggerExtensions
{
    public static ILoggingBuilder AddColorConsoleLogger(
        this ILoggingBuilder builder)
    {
        builder.AddConfiguration();

        builder.Services.TryAddEnumerable(
            ServiceDescriptor.Singleton<ILoggerProvider, ColorConsoleLoggerProvider>());

        LoggerProviderOptions.RegisterProviderOptions
            <ColorConsoleLoggerConfiguration, ColorConsoleLoggerProvider>(builder.Services);

        return builder;
    }

    public static ILoggingBuilder AddColorConsoleLogger(
        this ILoggingBuilder builder,
        Action<ColorConsoleLoggerConfiguration> configure)
    {
        builder.AddColorConsoleLogger();
        builder.Services.Configure(configure);

        return builder;
    }
}

Le ILoggingBuilder crée une ou plusieurs instances ILogger. Les instances ILogger sont utilisées par l’infrastructure pour consigner les informations.

Le code d’instanciation remplace les valeurs de couleur du fichier appsettings.json pour LogLevel.Warning et LogLevel.Error.

Lorsque vous exécutez cette application simple, elle affiche la sortie de couleur dans la fenêtre de console similaire à l’image suivante :

exemple de sortie couleur de l’enregistreur d’événements de console

Voir aussi

  • Last updated on