Partekatu bidez

Implementación de un proveedor de registro personalizado en .NET

Hay muchos proveedores de registro disponibles para las necesidades de registro habituales. Pero es posible que tenga que implementar un proveedor personalizado ILoggerProvider cuando uno de los proveedores disponibles no se adapte a las necesidades de la aplicación. En este artículo, aprenderá a implementar un proveedor de registro personalizado que se puede usar para colorear los registros en la consola.

Sugerencia

El código fuente de ejemplo del proveedor de registro personalizado está disponible en el repositorio de GitHub de docs.

Configuración de registrador personalizado de ejemplo

El registrador de ejemplo crea entradas de consola de color diferentes por nivel de registro e identificador de evento mediante el siguiente tipo de configuración:

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
    };
}

El código anterior establece el color predeterminado para el Information nivel en Green. el EventId valor es implícitamente 0.

Creación del registrador personalizado

El siguiente fragmento de código muestra la ILogger implementación:

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();
        }
    }
}

Cada instancia del registrador se crea pasando un nombre de categoría, que suele ser el tipo donde se crea el registrador. El IsEnabled método comprueba getCurrentConfig().LogLevelToColorMap.ContainsKey(logLevel) si el nivel de registro solicitado está habilitado (es decir, en el diccionario de niveles de registro de la configuración).

Es recomendable llamar a ILogger.IsEnabled dentro de las implementaciones de ILogger.Log, dado que cualquier consumidor podría llamar a Log y no hay garantía de que se haya comprobado previamente. El método IsEnabled debe ser muy rápido en la mayoría de las implementaciones.

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

Se instancia el registrador con name y un Func<ColorConsoleLoggerConfiguration> que devuelve la configuración actual.

Importante

La implementación de ILogger.Log verifica si el valor config.EventId está establecido. Cuando no se establece config.EventId o cuando coincide con el logEntry.EventIdexacto, el registrador registra en color.

Proveedor de registrador personalizado

El objeto ILoggerProvider es responsable de crear instancias de registrador. No es necesario crear una instancia de registrador por categoría, pero tiene sentido para algunos registradores, como NLog o log4net. Esta estrategia permite elegir diferentes destinos de salida de registro por categoría, como en el ejemplo siguiente:

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();
    }
}

En el código anterior, CreateLogger(String) crea una única instancia del ColorConsoleLogger por nombre de categoría y la almacena en el ConcurrentDictionary<TKey,TValue>.

La ColorConsoleLoggerProvider clase está decorada con dos atributos:

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

La configuración se puede especificar con cualquier proveedor de configuración válido. Fíjese en el siguiente archivo appsettings.json:

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

El archivo appsettings.json especifica que el color del Information nivel de registro es DarkGreen, que invalida el valor predeterminado establecido en el ColorConsoleLoggerConfiguration objeto .

Uso y registro del registrador personalizado

Por convención, los servicios se registran para la inserción de dependencias como parte de la rutina de inicio de una aplicación. En este ejemplo, el servicio de registro se registra directamente desde el archivo Program.cs .

Para agregar el proveedor de registro personalizado y el logger correspondiente, agregue un ILoggerProvider llamando a un método de extensión personalizado, AddColorConsoleLogger, en la propiedad IHostApplicationBuilder.Logging desde ILoggingBuilder.

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();

Por convención, los métodos de extensión de ILoggingBuilder se usan para registrar el proveedor personalizado:

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;
    }
}

El ILoggingBuilder crea una o varias instancias de ILogger. El marco usa las instancias de ILogger para registrar la información.

El código de creación de instancias invalida los valores de color del archivo appsettings.json para LogLevel.Warning y LogLevel.Error.

Al ejecutar esta aplicación sencilla, muestra la salida de color para la ventana de consola similar a la siguiente imagen:

Salida de ejemplo del registrador de la consola de color

Consulte también

  • Last updated on