Formatação do log do console

Artigo
04/11/2024

No .NET 5, o suporte para formatação personalizada foi adicionado aos logs do Microsoft.Extensions.Logging.Console console no namespace. Há três opções de formatação predefinidas disponíveis: Simple, Systemde Json.

Importante

Anteriormente, o ConsoleLoggerFormat enum permitia selecionar o formato de log desejado, legível por humanos, que era o Default, ou linha única, que também é conhecida como Systemd. No entanto, estes não eram personalizáveis e agora estão obsoletos.

Neste artigo, você aprenderá sobre o log do console formatters. O código-fonte de exemplo demonstra como:

Registar um novo formatador
Selecione um formatador registrado para usar
- Seja através de código ou configuração
Implementar um formatador personalizado
- Atualize a configuração via IOptionsMonitor<TOptions>
- Ativar formatação de cores personalizada

Gorjeta

Todo o código-fonte de exemplo de registro está disponível no Navegador de amostras para download. Para obter mais informações, consulte Procurar exemplos de código: fazendo login no .NET.

Formatador de registo

O Console provedor de registro em log tem vários formatters predefinidos e expõe a capacidade de criar seu próprio formatador personalizado. Para registar qualquer um dos formatters disponíveis, utilize o método de extensão correspondente Add{Type}Console :

Tipos disponíveis	Método para registar o tipo
ConsoleFormatterNames.Json	ConsoleLoggerExtensions.AddJsonConsole
ConsoleFormatterNames.Simple	ConsoleLoggerExtensions.AddSimpleConsole
ConsoleFormatterNames.Systemd	ConsoleLoggerExtensions.AddSystemdConsole

Simples

Para usar o formatador de Simple console, registre-o com AddSimpleConsole:

using Microsoft.Extensions.Logging;

using ILoggerFactory loggerFactory =
    LoggerFactory.Create(builder =>
        builder.AddSimpleConsole(options =>
        {
            options.IncludeScopes = true;
            options.SingleLine = true;
            options.TimestampFormat = "HH:mm:ss ";
        }));

ILogger<Program> logger = loggerFactory.CreateLogger<Program>();
using (logger.BeginScope("[scope is enabled]"))
{
    logger.LogInformation("Hello World!");
    logger.LogInformation("Logs contain timestamp and log level.");
    logger.LogInformation("Each log message is fit in a single line.");
}

No código-fonte de exemplo anterior, o ConsoleFormatterNames.Simple formatador foi registrado. Ele fornece logs com a capacidade de não apenas encapsular informações, como tempo e nível de log em cada mensagem de log, mas também permite a incorporação de cores ANSI e recuo de mensagens.

Quando este aplicativo de exemplo é executado, as mensagens de log são formatadas como mostrado abaixo:

Sistematizado

O ConsoleFormatterNames.Systemd registrador de console:

Usa o formato de nível de log "Syslog" e severidades
Não formata mensagens com cores
Sempre registra mensagens em uma única linha

Isso geralmente é útil para contêineres, que geralmente usam o registro em log do Systemd console. Com o .NET 5, o registrador de console também habilita uma versão compacta Simple que registra em uma única linha e também permite desabilitar cores, conforme mostrado em um exemplo anterior.

using Microsoft.Extensions.Logging;

using ILoggerFactory loggerFactory =
    LoggerFactory.Create(builder =>
        builder.AddSystemdConsole(options =>
        {
            options.IncludeScopes = true;
            options.TimestampFormat = "HH:mm:ss ";
        }));

ILogger<Program> logger = loggerFactory.CreateLogger<Program>();
using (logger.BeginScope("[scope is enabled]"))
{
    logger.LogInformation("Hello World!");
    logger.LogInformation("Logs contain timestamp and log level.");
    logger.LogInformation("Systemd console logs never provide color options.");
    logger.LogInformation("Systemd console logs always appear in a single line.");
}

O exemplo produz uma saída semelhante às seguintes mensagens de log:

JSON

Para gravar logs em um formato JSON, o formatador de Json console é usado. O código-fonte de exemplo mostra como um aplicativo ASP.NET Core pode registrá-lo. Usando o webapp modelo, crie um novo aplicativo ASP.NET Core com o comando dotnet new :

dotnet new webapp -o Console.ExampleFormatters.Json

Ao executar o aplicativo, usando o código do modelo, você obtém o formato de log padrão abaixo:

info: Console.ExampleFormatters.Json.Startup[0]
      Hello .NET friends!
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: https://localhost:5001
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5000
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: .\snippets\logging\console-formatter-json

Por padrão, o formatador de log do Simple console é selecionado com a configuração padrão. Você altera isso chamando AddJsonConsole o Program.cs:

using System.Text.Json;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);

builder.Logging.AddJsonConsole(options =>
{
    options.IncludeScopes = false;
    options.TimestampFormat = "HH:mm:ss ";
    options.JsonWriterOptions = new JsonWriterOptions
    {
        Indented = true
    };
});

using IHost host = builder.Build();

var logger =
    host.Services
        .GetRequiredService<ILoggerFactory>()
        .CreateLogger<Program>();

logger.LogInformation("Hello .NET friends!");

await host.RunAsync();

Como alternativa, você também pode configurar isso usando a configuração de log, como a encontrada no arquivo appsettings.json :

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft": "Warning",
            "Microsoft.Hosting.Lifetime": "Information"
        },
        "Console": {
            "LogLevel": {
                "Default": "Information",
                "Microsoft": "Warning",
                "Microsoft.Hosting.Lifetime": "Information"
            },
            "FormatterName": "json",
            "FormatterOptions": {
                "SingleLine": true,
                "IncludeScopes": true,
                "TimestampFormat": "HH:mm:ss ",
                "UseUtcTimestamp": true,
                "JsonWriterOptions": {
                    "Indented": true
                }
            }
        }
    },
    "AllowedHosts": "*"
}

Execute o aplicativo novamente, com a alteração acima, a mensagem de log agora está formatada como JSON:

{
  "Timestamp": "02:28:19 ",
  "EventId": 0,
  "LogLevel": "Information",
  "Category": "Console.ExampleFormatters.Json.Startup",
  "Message": "Hello .NET friends!",
  "State": {
    "Message": "Hello .NET friends!",
    "{OriginalFormat}": "Hello .NET friends!"
  }
}
{
  "Timestamp": "02:28:21 ",
  "EventId": 14,
  "LogLevel": "Information",
  "Category": "Microsoft.Hosting.Lifetime",
  "Message": "Now listening on: https://localhost:5001",
  "State": {
    "Message": "Now listening on: https://localhost:5001",
    "address": "https://localhost:5001",
    "{OriginalFormat}": "Now listening on: {address}"
  }
}
{
  "Timestamp": "02:28:21 ",
  "EventId": 14,
  "LogLevel": "Information",
  "Category": "Microsoft.Hosting.Lifetime",
  "Message": "Now listening on: http://localhost:5000",
  "State": {
    "Message": "Now listening on: http://localhost:5000",
    "address": "http://localhost:5000",
    "{OriginalFormat}": "Now listening on: {address}"
  }
}
{
  "Timestamp": "02:28:21 ",
  "EventId": 0,
  "LogLevel": "Information",
  "Category": "Microsoft.Hosting.Lifetime",
  "Message": "Application started. Press Ctrl\u002BC to shut down.",
  "State": {
    "Message": "Application started. Press Ctrl\u002BC to shut down.",
    "{OriginalFormat}": "Application started. Press Ctrl\u002BC to shut down."
  }
}
{
  "Timestamp": "02:28:21 ",
  "EventId": 0,
  "LogLevel": "Information",
  "Category": "Microsoft.Hosting.Lifetime",
  "Message": "Hosting environment: Development",
  "State": {
    "Message": "Hosting environment: Development",
    "envName": "Development",
    "{OriginalFormat}": "Hosting environment: {envName}"
  }
}
{
  "Timestamp": "02:28:21 ",
  "EventId": 0,
  "LogLevel": "Information",
  "Category": "Microsoft.Hosting.Lifetime",
  "Message": "Content root path: .\\snippets\\logging\\console-formatter-json",
  "State": {
    "Message": "Content root path: .\\snippets\\logging\\console-formatter-json",
    "contentRoot": ".\\snippets\\logging\\console-formatter-json",
    "{OriginalFormat}": "Content root path: {contentRoot}"
  }
}

Gorjeta

O Json formatador de console, por padrão, registra cada mensagem em uma única linha. Para torná-lo mais legível durante a configuração do formatador, defina JsonWriterOptions.Indented como true.

Atenção

Ao usar o formatador de console Json, não passe mensagens de log que já foram serializadas como JSON. A própria infraestrutura de registro em log já gerencia a serialização de mensagens de log, portanto, se você passar uma mensagem de log que já está serializada, ela será serializada duplamente, causando uma saída malformada.

Definir formatador com configuração

Os exemplos anteriores mostraram como registrar um formatador programaticamente. Alternativamente, isso pode ser feito com a configuração. Considere o código-fonte de exemplo de aplicativo Web anterior, se você atualizar o arquivo appsettings.json em vez de chamar ConfigureLogging o arquivo Program.cs , poderá obter o mesmo resultado. O arquivo atualizado appsettings.json configuraria o formatador da seguinte maneira:

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft": "Warning",
            "Microsoft.Hosting.Lifetime": "Information"
        },
        "Console": {
            "LogLevel": {
                "Default": "Information",
                "Microsoft": "Warning",
                "Microsoft.Hosting.Lifetime": "Information"
            },
            "FormatterName": "json",
            "FormatterOptions": {
                "SingleLine": true,
                "IncludeScopes": true,
                "TimestampFormat": "HH:mm:ss ",
                "UseUtcTimestamp": true,
                "JsonWriterOptions": {
                    "Indented": true
                }
            }
        }
    },
    "AllowedHosts": "*"
}

Os dois valores-chave que precisam ser definidos são "FormatterName" e "FormatterOptions". Se um formatador com o valor definido para "FormatterName" já estiver registrado, esse formatador será selecionado e suas propriedades poderão ser configuradas, desde que sejam fornecidas como uma chave dentro do "FormatterOptions" nó. Os nomes dos formatadores predefinidos estão reservados em ConsoleFormatterNames:

Implementar um formatador personalizado

Para implementar um formatador personalizado, você precisa:

Criar uma subclasse de ConsoleFormatter, que representa o formatador personalizado
Registe o seu formatador personalizado com
- ConsoleLoggerExtensions.AddConsole
- ConsoleLoggerExtensions.AddConsoleFormatter<TFormatter,TOptions>(ILoggingBuilder, Action<TOptions>)

Crie um método de extensão para lidar com isso para você:

using Microsoft.Extensions.Logging;

namespace Console.ExampleFormatters.Custom;

public static class ConsoleLoggerExtensions
{
    public static ILoggingBuilder AddCustomFormatter(
        this ILoggingBuilder builder,
        Action<CustomOptions> configure) =>
        builder.AddConsole(options => options.FormatterName = "customName")
            .AddConsoleFormatter<CustomFormatter, CustomOptions>(configure);
}

Os CustomOptions são definidos da seguinte forma:

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.Custom;

public sealed class CustomOptions : ConsoleFormatterOptions
{
    public string? CustomPrefix { get; set; }
}

No código anterior, as opções são uma subclasse de ConsoleFormatterOptions.

A AddConsoleFormatter API:

Regista uma subclasse de ConsoleFormatter
Manipula a configuração:
- Usa um token de alteração para sincronizar atualizações, com base no padrão de opções, e na interface IOptionsMonitor

using Console.ExampleFormatters.Custom;
using Microsoft.Extensions.Logging;

using ILoggerFactory loggerFactory =
    LoggerFactory.Create(builder =>
        builder.AddCustomFormatter(options =>
            options.CustomPrefix = " ~~~~~ "));

ILogger<Program> logger = loggerFactory.CreateLogger<Program>();
using (logger.BeginScope("TODO: Add logic to enable scopes"))
{
    logger.LogInformation("Hello World!");
    logger.LogInformation("TODO: Add logic to enable timestamp and log level info.");
}

Definir uma CustomFormatter subclasse de ConsoleFormatter:

using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Logging.Console;
using Microsoft.Extensions.Options;

namespace Console.ExampleFormatters.Custom;

public sealed class CustomFormatter : ConsoleFormatter, IDisposable
{
    private readonly IDisposable? _optionsReloadToken;
    private CustomOptions _formatterOptions;

    public CustomFormatter(IOptionsMonitor<CustomOptions> options)
        // Case insensitive
        : base("customName") =>
        (_optionsReloadToken, _formatterOptions) =
            (options.OnChange(ReloadLoggerOptions), options.CurrentValue);

    private void ReloadLoggerOptions(CustomOptions options) =>
        _formatterOptions = options;

    public override void Write<TState>(
        in LogEntry<TState> logEntry,
        IExternalScopeProvider? scopeProvider,
        TextWriter textWriter)
    {
        string? message =
            logEntry.Formatter?.Invoke(
                logEntry.State, logEntry.Exception);

        if (message is null)
        {
            return;
        }

        CustomLogicGoesHere(textWriter);
        textWriter.WriteLine(message);
    }

    private void CustomLogicGoesHere(TextWriter textWriter)
    {
        textWriter.Write(_formatterOptions.CustomPrefix);
    }

    public void Dispose() => _optionsReloadToken?.Dispose();
}

A API anterior CustomFormatter.Write<TState> dita qual texto é quebrado em torno de cada mensagem de log. Um padrão ConsoleFormatter deve ser capaz de envolver escopos, carimbos de data/hora e nível de severidade dos logs no mínimo. Além disso, você pode codificar cores ANSI nas mensagens de log e fornecer recuos desejados também. A implementação do CustomFormatter.Write<TState> carece dessas capacidades.

Para obter inspiração sobre como personalizar ainda mais a formatação, consulte as Microsoft.Extensions.Logging.Console implementações existentes no namespace:

Opções de configuração personalizadas

Para personalizar ainda mais a extensibilidade de log, sua classe derivada ConsoleFormatterOptions pode ser configurada a partir de qualquer provedor de configuração. Por exemplo, você pode usar o provedor de configuração JSON para definir suas opções personalizadas. Primeiro, defina sua ConsoleFormatterOptions subclasse.

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.CustomWithConfig;

public sealed class CustomWrappingConsoleFormatterOptions : ConsoleFormatterOptions
{
    public string? CustomPrefix { get; set; }

    public string? CustomSuffix { get; set; }
}

A classe de opções do formatador de console anterior define duas propriedades personalizadas, representando um prefixo e um sufixo. Em seguida, defina o arquivo de appsettings.json que configurará as opções do formatador do console.

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft": "Warning",
            "Microsoft.Hosting.Lifetime": "Information"
        },
        "Console": {
            "LogLevel": {
                "Default": "Information",
                "Microsoft": "Warning",
                "Microsoft.Hosting.Lifetime": "Information"
            },
            "FormatterName": "CustomTimePrefixingFormatter",
            "FormatterOptions": {
                "CustomPrefix": "|-<[",
                "CustomSuffix": "]>-|",
                "SingleLine": true,
                "IncludeScopes": true,
                "TimestampFormat": "HH:mm:ss.ffff ",
                "UseUtcTimestamp": true,
                "JsonWriterOptions": {
                    "Indented": true
                }
            }
        }
    },
    "AllowedHosts": "*"
}

No arquivo de configuração JSON anterior:

O "Logging" nó define um "Console"arquivo .
O "Console" nó especifica um "FormatterName" de "CustomTimePrefixingFormatter", que mapeia para um formatador personalizado.
O "FormatterOptions" nó define um "CustomPrefix", e "CustomSuffix", bem como algumas outras opções derivadas.

Gorjeta

O $.Logging.Console.FormatterOptions caminho JSON é reservado e será mapeado para um personalizado ConsoleFormatterOptions quando adicionado usando o AddConsoleFormatter método de extensão. Isso fornece a capacidade de definir propriedades personalizadas, além das disponíveis.

Considere o seguinte CustomDatePrefixingFormatter:

using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Logging.Console;
using Microsoft.Extensions.Options;

namespace Console.ExampleFormatters.CustomWithConfig;

public sealed class CustomTimePrefixingFormatter : ConsoleFormatter, IDisposable
{
    private readonly IDisposable? _optionsReloadToken;
    private CustomWrappingConsoleFormatterOptions _formatterOptions;

    public CustomTimePrefixingFormatter(
        IOptionsMonitor<CustomWrappingConsoleFormatterOptions> options)
        // Case insensitive
        : base(nameof(CustomTimePrefixingFormatter))
    {
        _optionsReloadToken = options.OnChange(ReloadLoggerOptions);
        _formatterOptions = options.CurrentValue;
    }

    private void ReloadLoggerOptions(CustomWrappingConsoleFormatterOptions options) =>
        _formatterOptions = options;

    public override void Write<TState>(
        in LogEntry<TState> logEntry,
        IExternalScopeProvider? scopeProvider,
        TextWriter textWriter)
    {
        string message =
            logEntry.Formatter(
                logEntry.State, logEntry.Exception);

        if (message == null)
        {
            return;
        }

        WritePrefix(textWriter);
        textWriter.Write(message);
        WriteSuffix(textWriter);
    }

    private void WritePrefix(TextWriter textWriter)
    {
        DateTime now = _formatterOptions.UseUtcTimestamp
            ? DateTime.UtcNow
            : DateTime.Now;

        textWriter.Write($"""
            {_formatterOptions.CustomPrefix} {now.ToString(_formatterOptions.TimestampFormat)}
            """);
    }

    private void WriteSuffix(TextWriter textWriter) =>
        textWriter.WriteLine($" {_formatterOptions.CustomSuffix}");

    public void Dispose() => _optionsReloadToken?.Dispose();
}

Na implementação do formatador anterior:

Os CustomWrappingConsoleFormatterOptions são monitorados quanto à mudança e atualizados de acordo.
As mensagens gravadas são encapsuladas com o prefixo e o sufixo configurados.
Um carimbo de data/hora é adicionado após o prefixo, mas antes da mensagem usando os valores e configurados ConsoleFormatterOptions.UseUtcTimestamp ConsoleFormatterOptions.TimestampFormat .

Para usar opções de configuração personalizadas, com implementações de formatador personalizadas, adicione ao chamar ConfigureLogging(IHostBuilder, Action<HostBuilderContext,ILoggingBuilder>).

using Console.ExampleFormatters.CustomWithConfig;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);

builder.Logging.AddConsole()
    .AddConsoleFormatter<
        CustomTimePrefixingFormatter, CustomWrappingConsoleFormatterOptions>();

using IHost host = builder.Build();

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

using (logger.BeginScope("Logging scope"))
{
    logger.LogInformation("Hello World!");
    logger.LogInformation("The .NET developer community happily welcomes you.");
}

A saída do console a seguir é semelhante ao que você pode esperar ver ao usar este CustomTimePrefixingFormatter.

|-<[ 15:03:15.6179 Hello World! ]>-|
|-<[ 15:03:15.6347 The .NET developer community happily welcomes you. ]>-|

Implementar formatação de cores personalizada

Para habilitar corretamente os recursos de cores em seu formatador de log personalizado, você pode estender o SimpleConsoleFormatterOptions como ele tem uma SimpleConsoleFormatterOptions.ColorBehavior propriedade que pode ser útil para habilitar cores em logs.

Crie um CustomColorOptions que deriva de SimpleConsoleFormatterOptions:

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.Custom;

public class CustomColorOptions : SimpleConsoleFormatterOptions
{
    public string? CustomPrefix { get; set; }
}

Em seguida, escreva alguns métodos de extensão em uma TextWriterExtensions classe que permitam incorporar convenientemente cores codificadas ANSI em mensagens de log formatadas:

namespace Console.ExampleFormatters.Custom;

public static class TextWriterExtensions
{
    const string DefaultForegroundColor = "\x1B[39m\x1B[22m";
    const string DefaultBackgroundColor = "\x1B[49m";

    public static void WriteWithColor(
        this TextWriter textWriter,
        string message,
        ConsoleColor? background,
        ConsoleColor? foreground)
    {
        // Order:
        //   1. background color
        //   2. foreground color
        //   3. message
        //   4. reset foreground color
        //   5. reset background color

        var backgroundColor = background.HasValue ? GetBackgroundColorEscapeCode(background.Value) : null;
        var foregroundColor = foreground.HasValue ? GetForegroundColorEscapeCode(foreground.Value) : null;

        if (backgroundColor != null)
        {
            textWriter.Write(backgroundColor);
        }
        if (foregroundColor != null)
        {
            textWriter.Write(foregroundColor);
        }

        textWriter.WriteLine(message);

        if (foregroundColor != null)
        {
            textWriter.Write(DefaultForegroundColor);
        }
        if (backgroundColor != null)
        {
            textWriter.Write(DefaultBackgroundColor);
        }
    }

    static string GetForegroundColorEscapeCode(ConsoleColor color) =>
        color switch
        {
            ConsoleColor.Black => "\x1B[30m",
            ConsoleColor.DarkRed => "\x1B[31m",
            ConsoleColor.DarkGreen => "\x1B[32m",
            ConsoleColor.DarkYellow => "\x1B[33m",
            ConsoleColor.DarkBlue => "\x1B[34m",
            ConsoleColor.DarkMagenta => "\x1B[35m",
            ConsoleColor.DarkCyan => "\x1B[36m",
            ConsoleColor.Gray => "\x1B[37m",
            ConsoleColor.Red => "\x1B[1m\x1B[31m",
            ConsoleColor.Green => "\x1B[1m\x1B[32m",
            ConsoleColor.Yellow => "\x1B[1m\x1B[33m",
            ConsoleColor.Blue => "\x1B[1m\x1B[34m",
            ConsoleColor.Magenta => "\x1B[1m\x1B[35m",
            ConsoleColor.Cyan => "\x1B[1m\x1B[36m",
            ConsoleColor.White => "\x1B[1m\x1B[37m",

            _ => DefaultForegroundColor
        };

    static string GetBackgroundColorEscapeCode(ConsoleColor color) =>
        color switch
        {
            ConsoleColor.Black => "\x1B[40m",
            ConsoleColor.DarkRed => "\x1B[41m",
            ConsoleColor.DarkGreen => "\x1B[42m",
            ConsoleColor.DarkYellow => "\x1B[43m",
            ConsoleColor.DarkBlue => "\x1B[44m",
            ConsoleColor.DarkMagenta => "\x1B[45m",
            ConsoleColor.DarkCyan => "\x1B[46m",
            ConsoleColor.Gray => "\x1B[47m",

            _ => DefaultBackgroundColor
        };
}

Um formatador de cores personalizado que lida com a aplicação de cores personalizadas pode ser definido da seguinte forma:

using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Logging.Console;
using Microsoft.Extensions.Options;

namespace Console.ExampleFormatters.Custom;

public sealed class CustomColorFormatter : ConsoleFormatter, IDisposable
{
    private readonly IDisposable? _optionsReloadToken;
    private CustomColorOptions _formatterOptions;

    private bool ConsoleColorFormattingEnabled =>
        _formatterOptions.ColorBehavior == LoggerColorBehavior.Enabled ||
        _formatterOptions.ColorBehavior == LoggerColorBehavior.Default &&
        System.Console.IsOutputRedirected == false;

    public CustomColorFormatter(IOptionsMonitor<CustomColorOptions> options)
        // Case insensitive
        : base("customName") =>
        (_optionsReloadToken, _formatterOptions) =
            (options.OnChange(ReloadLoggerOptions), options.CurrentValue);

    private void ReloadLoggerOptions(CustomColorOptions options) =>
        _formatterOptions = options;

    public override void Write<TState>(
        in LogEntry<TState> logEntry,
        IExternalScopeProvider? scopeProvider,
        TextWriter textWriter)
    {
        if (logEntry.Exception is null)
        {
            return;
        }

        string? message =
            logEntry.Formatter?.Invoke(
                logEntry.State, logEntry.Exception);

        if (message is null)
        {
            return;
        }

        CustomLogicGoesHere(textWriter);
        textWriter.WriteLine(message);
    }

    private void CustomLogicGoesHere(TextWriter textWriter)
    {
        if (ConsoleColorFormattingEnabled)
        {
            textWriter.WriteWithColor(
                _formatterOptions.CustomPrefix ?? string.Empty,
                ConsoleColor.Black,
                ConsoleColor.Green);
        }
        else
        {
            textWriter.Write(_formatterOptions.CustomPrefix);
        }
    }

    public void Dispose() => _optionsReloadToken?.Dispose();
}

Quando você executa o aplicativo, os logs mostrarão a CustomPrefix mensagem na cor verde quando FormatterOptions.ColorBehavior for Enabled.

Nota

Quando LoggerColorBehavior é Disabled, as mensagens de log não interpretam códigos de cores ANSI incorporados nas mensagens de log. Em vez disso, eles produzem a mensagem bruta. Por exemplo, considere o seguinte:

logger.LogInformation("Random log \x1B[42mwith green background\x1B[49m message");

Isso resultaria na string literal e ela não é colorida.

Random log \x1B[42mwith green background\x1B[49m message

Partilhar via

Formatação do log do console

Formatador de registo

Simples

Sistematizado

JSON

Definir formatador com configuração

Implementar um formatador personalizado

Opções de configuração personalizadas

Implementar formatação de cores personalizada

Consulte também

Recursos adicionais