Formatering av konsolloggar

Artikel
04/11/2024

I .NET 5 har stöd för anpassad formatering lagts till i konsolloggarna i Microsoft.Extensions.Logging.Console namnområdet. Det finns tre fördefinierade formateringsalternativ: Simple, Systemdoch Json.

Viktigt!

ConsoleLoggerFormat Tidigare tilläts uppräkningen för att välja önskat loggformat, antingen mänskligt läsbart som var , Defaulteller en rad som även kallas Systemd. Dessa var dock inte anpassningsbara och är nu inaktuella.

I den här artikeln får du lära dig mer om konsolloggformaterare. Exempelkällan visar hur du:

Registrera en ny formatering
Välj en registrerad formatering som ska användas
- Antingen via kod eller konfiguration
Implementera en anpassad formatering
- Uppdatera konfigurationen via IOptionsMonitor<TOptions>
- Aktivera anpassad färgformatering

Dricks

All källkod för loggningsexemplet är tillgänglig i Exempelwebbläsaren för nedladdning. Mer information finns i Bläddra bland kodexempel: Loggning i .NET.

Registrera formatering

Loggningsprovidern Console har flera fördefinierade formaterare och gör det möjligt att skapa en egen anpassad formaterare. Om du vill registrera någon av de tillgängliga formatrarna använder du motsvarande Add{Type}Console tilläggsmetod:

Tillgängliga typer	Metod för att registrera typ
ConsoleFormatterNames.Json	ConsoleLoggerExtensions.AddJsonConsole
ConsoleFormatterNames.Simple	ConsoleLoggerExtensions.AddSimpleConsole
ConsoleFormatterNames.Systemd	ConsoleLoggerExtensions.AddSystemdConsole

Enkel

Om du vill använda Simple konsolformaterare registrerar du den med 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.");
}

I föregående exempel på källkod ConsoleFormatterNames.Simple registrerades formatatorn. Det ger loggar möjligheten att inte bara omsluta information, till exempel tid och loggnivå i varje loggmeddelande, utan även tillåta ANSI-färginbäddning och indrag av meddelanden.

När den här exempelappen körs formateras loggmeddelandena enligt nedan:

Systemd

Konsolloggaren ConsoleFormatterNames.Systemd :

Använder loggnivåformatet "Syslog" och allvarlighetsgraden
Formaterar inte meddelanden med färger
Loggar alltid meddelanden på en enda rad

Detta är ofta användbart för containrar, som ofta använder Systemd konsolloggning. Med .NET 5 Simple möjliggör konsolloggaren även en kompakt version som loggar på en enda rad, och tillåter även inaktivering av färger som visas i ett tidigare exempel.

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

Exemplet genererar utdata som liknar följande loggmeddelanden:

Json

Om du vill skriva loggar i JSON-format Json används konsolformaterare. Exempelkällan visar hur en ASP.NET Core-app kan registrera den. Skapa en ny ASP.NET Core-app med det nya dotnet-kommandot med hjälp av mallen:webapp

dotnet new webapp -o Console.ExampleFormatters.Json

När du kör appen med hjälp av mallkoden får du standardloggformatet nedan:

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

Som standard Simple är konsolloggformaterare valt med standardkonfiguration. Du ändrar detta genom att anropa AddJsonConsole i 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();

Du kan också konfigurera detta med hjälp av loggningskonfigurationen, till exempel den som finns i filen 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": "*"
}

Kör appen igen, med ovanstående ändring formateras loggmeddelandet nu som 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}"
  }
}

Dricks

Konsolformaterare Json loggar som standard varje meddelande på en enda rad. För att göra det mer läsbart när du konfigurerar formateringen anger du JsonWriterOptions.Indented till true.

Varning

När du använder Json-konsolformaterare ska du inte skicka loggmeddelanden som redan har serialiserats som JSON. Själva loggningsinfrastrukturen hanterar redan serialiseringen av loggmeddelanden, så om du ska skicka ett loggmeddelande som redan är serialiserat kommer det att vara dubbelt serialiserat, vilket orsakar felaktiga utdata.

Ange formatering med konfiguration

De tidigare exemplen har visat hur du registrerar en formatering programmatiskt. Du kan också göra detta med konfigurationen. Tänk på den tidigare källkoden för webbprogrammets exempel, om du uppdaterar appsettings.json-filen i stället för att anropa ConfigureLogging i Program.cs-filen, kan du få samma resultat. Den uppdaterade appsettings.json filen konfigurerar formaterare enligt följande:

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

De två nyckelvärden som måste anges är "FormatterName" och "FormatterOptions". Om en formaterare med värdet som angetts för "FormatterName" redan har registrerats väljs formateringsfunktionen och dess egenskaper kan konfigureras så länge de anges som en nyckel i "FormatterOptions" noden. De fördefinierade formateringsnamnen är reserverade under ConsoleFormatterNames:

Implementera en anpassad formatering

Om du vill implementera en anpassad formatering måste du:

Skapa en underklass av ConsoleFormatter, detta representerar din anpassade formaterare
Registrera din anpassade formatering med
- ConsoleLoggerExtensions.AddConsole
- ConsoleLoggerExtensions.AddConsoleFormatter<TFormatter,TOptions>(ILoggingBuilder, Action<TOptions>)

Skapa en tilläggsmetod för att hantera detta åt dig:

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

CustomOptions Definieras enligt följande:

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.Custom;

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

I föregående kod är alternativen en underklass av ConsoleFormatterOptions.

API:et AddConsoleFormatter :

Registrerar en underklass av ConsoleFormatter
Hanterar konfiguration:
- Använder en ändringstoken för att synkronisera uppdateringar baserat på alternativmönstret och gränssnittet 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.");
}

Definiera en CustomFormatter underklass av 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();
}

Det föregående CustomFormatter.Write<TState> API:et avgör vilken text som omsluts av varje loggmeddelande. En standard ConsoleFormatter bör kunna omsluta omfång, tidsstämplar och allvarlighetsgrad för loggar som minst. Dessutom kan du koda ANSI-färger i loggmeddelandena och ange önskade indrag. Implementeringen av saknar CustomFormatter.Write<TState> dessa funktioner.

Information om hur du anpassar formateringen ytterligare finns i de befintliga implementeringarna i Microsoft.Extensions.Logging.Console namnområdet:

Anpassade konfigurationsalternativ

För att ytterligare anpassa utökningsbarheten för loggning kan din härledda ConsoleFormatterOptions klass konfigureras från valfri konfigurationsprovider. Du kan till exempel använda JSON-konfigurationsprovidern för att definiera dina anpassade alternativ. Definiera först underklassen ConsoleFormatterOptions .

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.CustomWithConfig;

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

    public string? CustomSuffix { get; set; }
}

Föregående konsolformateringsalternativklass definierar två anpassade egenskaper som representerar ett prefix och suffix. Definiera sedan den appsettings.json fil som konfigurerar alternativen för konsolformatering.

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

I föregående JSON-konfigurationsfil:

Noden "Logging" definierar en "Console".
Noden "Console" anger en "FormatterName" av "CustomTimePrefixingFormatter", som mappar till en anpassad formaterare.
Noden "FormatterOptions" definierar en "CustomPrefix", och "CustomSuffix", samt några andra härledda alternativ.

Dricks

JSON-sökvägen $.Logging.Console.FormatterOptions är reserverad och mappas till en anpassad ConsoleFormatterOptions när den läggs till med hjälp av AddConsoleFormatter tilläggsmetoden. Detta ger möjlighet att definiera anpassade egenskaper utöver de som är tillgängliga.

Tänk på följande 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();
}

I föregående formateringsimplementering:

CustomWrappingConsoleFormatterOptions Övervakas för ändring och uppdateras därefter.
Meddelanden som skrivs omsluts med det konfigurerade prefixet och suffixet.
En tidsstämpel läggs till efter prefixet, men före meddelandet med hjälp av de konfigurerade ConsoleFormatterOptions.UseUtcTimestamp värdena och ConsoleFormatterOptions.TimestampFormat .

Om du vill använda anpassade konfigurationsalternativ, med anpassade formateringsimplementeringar, lägger du till när du anropar 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.");
}

Följande konsolutdata liknar vad du kan förvänta dig av att använda den här CustomTimePrefixingFormatter.

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

Implementera anpassad färgformatering

För att kunna aktivera färgfunktioner korrekt i din anpassade loggningsformaterare kan du utöka SimpleConsoleFormatterOptions eftersom den har en SimpleConsoleFormatterOptions.ColorBehavior egenskap som kan vara användbar för att aktivera färger i loggar.

Skapa en CustomColorOptions som härleds från SimpleConsoleFormatterOptions:

using Microsoft.Extensions.Logging.Console;

namespace Console.ExampleFormatters.Custom;

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

Skriv sedan några tilläggsmetoder i en TextWriterExtensions klass som gör det möjligt att enkelt bädda in ANSI-kodade färger i formaterade loggmeddelanden:

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

En anpassad färgformaterare som hanterar användning av anpassade färger kan definieras på följande sätt:

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

När du kör programmet visar loggarna CustomPrefix meddelandet i färgen grön när FormatterOptions.ColorBehavior är Enabled.

Kommentar

När LoggerColorBehavior är Disabledtolkar inte loggmeddelanden inbäddade ANSI-färgkoder i loggmeddelanden. I stället matar de ut råmeddelandet. Tänk till exempel på följande:

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

Detta skulle mata ut den ordagranna strängen och den är inte färglagd.

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

Share via

Formatering av konsolloggar

Registrera formatering

Enkel

Systemd

Json

Ange formatering med konfiguration

Implementera en anpassad formatering

Anpassade konfigurationsalternativ

Implementera anpassad färgformatering

Se även

Feedback

Ytterligare resurser