Mise en forme des journaux de la console

Le namespace Microsoft.Extensions.Logging.Console prend en charge la mise en forme personnalisée dans les journaux de la console. Il existe trois options de mise en forme prédéfinies disponibles : Simple, Systemdet Json.

Important

Avant .NET 5, l’énumération ConsoleLoggerFormat autorisait la sélection du format de journal souhaité, soit le format lisible par l'homme, soit la Default ligne unique, également connu sous le nom de Systemd. Toutefois, ces éléments n’ont pas été personnalisables et sont désormais déconseillés.

Dans cet article, vous allez découvrir les formatters de logs de console. L’exemple de code source montre comment :

Inscrivez un nouveau formateur.
Sélectionnez un formateur enregistré à utiliser, soit par le code, soit par la configuration.
Implémentez un formateur personnalisé. Vous mettez à jour la configuration via IOptionsMonitor<TOptions> et activez la mise en forme de couleur personnalisée.

Conseil / Astuce

Tous les exemples de code source de journalisation sont disponibles dans l’Explorateur d’exemples pour téléchargement. Pour plus d’informations, consultez Parcourir les exemples de code : Journalisation dans .NET.

Inscrire le formateur

Le Console fournisseur de journalisation a plusieurs formateurs prédéfinis et expose la possibilité de créer votre propre formateur personnalisé. Pour enregistrer l’un des formatteurs disponibles, utilisez la méthode d’extension appropriée Add{Type}Console :

Types disponibles	Méthode pour inscrire le type
ConsoleFormatterNames.Json	ConsoleLoggerExtensions.AddJsonConsole
ConsoleFormatterNames.Simple	ConsoleLoggerExtensions.AddSimpleConsole
ConsoleFormatterNames.Systemd	ConsoleLoggerExtensions.AddSystemdConsole

Simple

Pour utiliser le formateur de console Simple, enregistrez-le avec 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.");
}

Dans l’exemple de code source précédent, le formateur de mise en forme ConsoleFormatterNames.Simple a été enregistré. Il fournit des journaux d’activité qui permettent non seulement d’encapsuler des informations telles que le temps et le niveau de journal dans chaque message de journal, mais également d’incorporer des couleurs ANSI et l'indentation des messages.

Lorsque cet exemple d’application est exécuté, les messages de journal sont mis en forme comme indiqué ci-dessous :

Systemd

L’enregistreur d’événements ConsoleFormatterNames.Systemd de console :

Utilise le format de niveaux de journalisation « Syslog » et les gravités.
Ne formate pas les messages avec des couleurs.
Consigne toujours les messages dans une seule ligne.

Cela est couramment utile pour les conteneurs, qui utilisent souvent la journalisation de la console Systemd. L’enregistreur Simple d’événements de console active également une version compacte qui journalise dans une seule ligne et permet également de désactiver les couleurs comme indiqué dans un exemple précédent.

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.");
}

L’exemple produit une sortie similaire aux messages de journal suivants :

Json

Pour écrire des fichiers journaux au format JSON, le Json formatteur de console est utilisé. L’exemple de code source montre comment une application ASP.NET Core peut l’inscrire. À l’aide du webapp modèle, créez une application ASP.NET Core avec la commande dotnet new :

dotnet new webapp -o Console.ExampleFormatters.Json

Lors de l’exécution de l’application, à l’aide du code de modèle, vous obtenez le format de journal par défaut ci-dessous :

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

Par défaut, le formateur de journal de console Simple est sélectionné avec la configuration par défaut. Vous modifiez cela en appelant AddJsonConsole dans le 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();

Vous pouvez également configurer cela à l’aide de la configuration de journalisation, telle que celle trouvée dans le fichier 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": "*"
}

Réexécutez l’application, avec la modification ci-dessus, le message de journal est désormais mis en forme au format 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}"
  }
}

Conseil / Astuce

Le Json formateur de console, par défaut, enregistre chaque message dans une seule ligne. Pour le rendre plus lisible lors de la configuration du formateur, définissez JsonWriterOptions.Indented sur true.

Caution

Lorsque vous utilisez le formateur de console JSON, ne transmettez pas les messages de journal qui ont déjà été sérialisés en tant que JSON. L’infrastructure de journalisation elle-même gère la sérialisation des messages de journalisation. Par conséquent, si vous transmettez un message de journal déjà sérialisé, il sera double sérialisé, ce qui entraîne une sortie malformée.

Définir le formateur avec la configuration

Les exemples précédents ont montré comment inscrire un formateur par voie de programmation. Il est également possible d'effectuer cette opération avec la configuration. Considérez l’exemple de code source de l’application web précédente, si vous mettez à jour le fichier appsettings.json plutôt que d’appeler ConfigureLogging dans le fichier Program.cs , vous pouvez obtenir le même résultat. Le fichier mis à jour appsettings.json configure le formateur comme suit :

{
    "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": "*"
}

Les deux valeurs clés qui doivent être définies sont "FormatterName" et "FormatterOptions". Si un formateur de texte dont la valeur pour "FormatterName" est déjà enregistrée, ce formateur est sélectionné et ses propriétés peuvent être configurées tant qu’elles sont fournies en tant que clé à l'intérieur du nœud "FormatterOptions". Les noms de formatteur prédéfinis sont réservés pour ConsoleFormatterNames:

Implémenter un formateur personnalisé

Pour implémenter une mise en forme personnalisée, vous devez :

Créez une sous-classe de ConsoleFormatter qui représente votre formatteur personnalisé.
Enregistrez votre formatteur personnalisé avec :
- ConsoleLoggerExtensions.AddConsole
- ConsoleLoggerExtensions.AddConsoleFormatter<TFormatter,TOptions>(ILoggingBuilder, Action<TOptions>)

Créez une méthode d’extension pour gérer cela pour vous :

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

Les CustomOptions éléments sont définis comme suit :

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.Custom;

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

Dans le code précédent, les options sont une sous-classe de ConsoleFormatterOptions.

L’API AddConsoleFormatter :

Inscrit une sous-classe de ConsoleFormatter.
Gère la configuration. Il utilise un jeton de modification pour synchroniser les mises à jour, en fonction du modèle d’options et de l’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.");
}

Définir une CustomFormatter sous-classe 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();
}

L’API précédente CustomFormatter.Write<TState> détermine le texte qui est encapsulé autour de chaque message de journal. Une norme ConsoleFormatter devrait pouvoir encapsuler au minimum les étendues, les horodatages et le niveau de gravité des journaux d'enregistrement. En outre, vous pouvez encoder les couleurs ANSI dans les messages de journal et fournir également des retraits souhaités. L’implémentation de l'CustomFormatter.Write<TState> manque certaines fonctionnalités.

Pour plus d’inspiration sur la personnalisation de la mise en forme, consultez les implémentations existantes dans le namespace Microsoft.Extensions.Logging.Console.

Options de configuration personnalisées

Pour personnaliser davantage l’extensibilité de journalisation, votre classe dérivée ConsoleFormatterOptions peut être configurée à partir de n’importe quel fournisseur de configuration. Par exemple, vous pouvez utiliser le fournisseur de configuration JSON pour définir vos options personnalisées. Commencez par définir votre ConsoleFormatterOptions sous-classe.

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.CustomWithConfig;

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

    public string? CustomSuffix { get; set; }
}

La classe d’options de formateur de console précédente définit deux propriétés personnalisées représentant un préfixe et un suffixe. Ensuite, définissez le fichier appsettings.json qui configurera vos options de formateur de 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": "*"
}

Dans le fichier de configuration JSON précédent :

Le "Logging" nœud définit un "Console".
Le "Console" nœud spécifie un "FormatterName" de "CustomTimePrefixingFormatter", qui correspond à un formateur personnalisé.
Le "FormatterOptions" nœud définit un "CustomPrefix", et "CustomSuffix", ainsi que quelques autres options dérivées.

Conseil / Astuce

Le $.Logging.Console.FormatterOptions chemin d’accès JSON est réservé et sera mappé à un ConsoleFormatterOptions personnalisé lorsqu'il est ajouté avec la méthode d'extension AddConsoleFormatter. Cela permet de définir des propriétés personnalisées, en plus des propriétés disponibles.

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

Dans l’implémentation du formatter précédent :

Les CustomWrappingConsoleFormatterOptions sont surveillés pour tout changement et mis à jour en conséquence.
Les messages écrits sont encapsulés avec le préfixe configuré et le suffixe.
Un horodatage est ajouté après le préfixe, mais avant le message en utilisant les valeurs configurées ConsoleFormatterOptions.UseUtcTimestamp et ConsoleFormatterOptions.TimestampFormat.

Pour utiliser des options de configuration personnalisées, avec des implémentations de formateur personnalisées, ajoutez lors de l’appel 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.");
}

La sortie de la console suivante est similaire à ce à quoi vous pourriez vous attendre en utilisant ce CustomTimePrefixingFormatter.

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

Implémenter une mise en forme de couleur personnalisée

Pour activer correctement les fonctionnalités de couleur dans votre formateur de journalisation personnalisé, vous pouvez étendre SimpleConsoleFormatterOptions, car il possède une propriété SimpleConsoleFormatterOptions.ColorBehavior qui peut être utile pour activer les couleurs dans les journaux.

Créez un CustomColorOptions qui dérive de SimpleConsoleFormatterOptions:

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.Custom;

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

Ensuite, écrivez certaines méthodes d’extension dans une TextWriterExtensions classe qui permettent d’incorporer facilement des couleurs codées ANSI dans les messages de journal mis en forme :

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

Un formateur de couleurs personnalisé qui gère l’application de couleurs personnalisées peut être défini comme suit :

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

Lorsque vous exécutez l’application, les journaux affichent le CustomPrefix message en vert de couleur lorsque FormatterOptions.ColorBehavior c’est Enabled.

Note

Quand LoggerColorBehavior est Disabled, les messages de journal n’interprètent pas les codes de couleur ANSI intégrés. Au lieu de cela, ils génèrent le message brut. Prenons l’exemple suivant :

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

Cela produit la chaîne telle quelle et elle n’est pas colorisée.

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

Voir aussi

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-02-05

Partager via

Mise en forme des journaux de la console

Inscrire le formateur

Simple

Systemd

Json

Définir le formateur avec la configuration

Implémenter un formateur personnalisé

Options de configuration personnalisées

Implémenter une mise en forme de couleur personnalisée

Voir aussi

Commentaires

Ressources supplémentaires