Sdílet prostřednictvím

Protokolování ASP.NET Core Blazor

  • Článek

Poznámka:

Toto není nejnovější verze tohoto článku. Aktuální verzi najdete ve verzi .NET 8 tohoto článku.

Důležité

Tyto informace se týkají předběžného vydání produktu, který může být podstatně změněn před komerčním vydáním. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Aktuální verzi najdete ve verzi .NET 8 tohoto článku.

Tento článek vysvětluje Blazor protokolování aplikací, včetně konfigurace a způsobu zápisu zpráv protokolu ze Razor součástí.

Konfigurace

Konfiguraci protokolování je možné načíst ze souborů nastavení aplikace. Další informace najdete v tématu ASP.NET Konfigurace jádraBlazor.

Na výchozích úrovních protokolů a bez konfigurace dalších zprostředkovatelů protokolování:

Pokud je aplikace nakonfigurovaná v souboru projektu tak, aby používala implicitní obory názvů (<ImplicitUsings>enable</ImplicitUsings>), direktiva using pro Microsoft.Extensions.Logging rozhraní API nebo jakékoli rozhraní API ve LoggerExtensions třídě se nevyžaduje pro podporu dokončování a sestavování aplikací v sadě API Visual Studio IntelliSense . Pokud nejsou povoleny implicitní obory názvů, Razor komponenty musí explicitně definovat @using direktivy pro protokolování oborů názvů, které nejsou importovány prostřednictvím _Imports.razor souboru.

Úrovně protokolování

Úrovně protokolů odpovídají úrovním protokolu ASP.NET Core, které jsou uvedené v dokumentaci k rozhraní API na adrese LogLevel.

Razor protokolování komponent

Direktiva using pro Microsoft.Extensions.Logging podporu dokončování IntelliSense pro rozhraní API, jako LogWarning jsou například a LogError.

Následující příklad:

  • ILogger Vloží (ILogger<Counter1>) objekt k vytvoření protokolovacího nástroje. Kategorie protokolu je plně kvalifikovaný název typu komponenty . Counter
  • Volá metodu LogWarning, která protokoluje na úrovni Warning.

Counter1.razor:

@page "/counter-1"
@inject ILogger<Counter1> Logger

<PageTitle>Counter 1</PageTitle>

<h1>Counter 1</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-1"
@inject ILogger<Counter1> Logger

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-1"
@inject ILogger<Counter1> Logger

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-1"
@using Microsoft.Extensions.Logging
@inject ILogger<Counter1> Logger

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-1"
@using Microsoft.Extensions.Logging
@inject ILogger<Counter1> Logger

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        Logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

Následující příklad ukazuje protokolování pomocí ILoggerFactory komponent.

Counter2.razor:

@page "/counter-2"
@inject ILoggerFactory LoggerFactory

<PageTitle>Counter 2</PageTitle>

<h1>Counter 2</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        var logger = LoggerFactory.CreateLogger<Counter2>();
        logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-2"
@inject ILoggerFactory LoggerFactory

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        var logger = LoggerFactory.CreateLogger<Counter2>();
        logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-2"
@inject ILoggerFactory LoggerFactory

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        var logger = LoggerFactory.CreateLogger<Counter2>();
        logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-2"
@using Microsoft.Extensions.Logging
@inject ILoggerFactory LoggerFactory

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        var logger = LoggerFactory.CreateLogger<Counter2>();
        logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

@page "/counter-2"
@using Microsoft.Extensions.Logging
@inject ILoggerFactory LoggerFactory

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        var logger = LoggerFactory.CreateLogger<Counter2>();
        logger.LogWarning("Someone has clicked me!");

        currentCount++;
    }
}

Protokolování na straně serveru

Obecné pokyny k protokolování ASP.NET Core najdete v tématu Protokolování v .NET Core a ASP.NET Core.

Protokolování na straně klienta

Ne každá funkce protokolování ASP.NET Core je podporovaná na straně klienta. Například komponenty na straně klienta nemají přístup k systému souborů nebo síti klienta, takže zápis protokolů do fyzického nebo síťového úložiště klienta není možný. Pokud používáte službu protokolování třetí strany navrženou tak, aby fungovala s jednostrákovými aplikacemi (SPA), postupujte podle pokynů k zabezpečení služby. Mějte na paměti, že každá část dat, včetně klíčů nebo tajných kódů uložených na straně klienta, jsou nezabezpečená a můžou je snadno zjistit uživatelé se zlými úmysly.

V závislosti na verzi rozhraní a funkcích protokolování můžou implementace protokolování vyžadovat přidání oboru názvů do Microsoft.Extensions.LoggingProgram souboru:

using Microsoft.Extensions.Logging;

Nakonfigurujte protokolování v aplikacích na straně klienta s WebAssemblyHostBuilder.Logging vlastností. Vlastnost Logging je typu ILoggingBuilder, takže rozšiřující metody ILoggingBuilder jsou podporovány.

Chcete-li nastavit minimální úroveň protokolování, zavolejte LoggingBuilderExtensions.SetMinimumLevel tvůrce hostitelů v Program souboru pomocí LogLevel. Následující příklad nastaví minimální úroveň protokolu na Warning:

builder.Logging.SetMinimumLevel(LogLevel.Warning);

Přihlášení k souboru na straně Program klienta

Protokolování se podporuje v aplikacích na straně klienta po WebAssemblyHostBuilder vytvoření pomocí interního zprostředkovatele protokolovacího nástroje konzoly (WebAssemblyConsoleLoggerProvider referenční zdroj) rozhraní.

V souboru Program:

var host = builder.Build();

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

logger.LogInformation("Logged after the app is built in the Program file.");

await host.RunAsync();

výstup konzoly Vývojářské nástroje:

info: Program[0]
Logged after the app is built in the Program file.

Poznámka:

Odkazy na dokumentaci k referenčnímu zdroji .NET obvykle načítají výchozí větev úložiště, která představuje aktuální vývoj pro příští verzi .NET. Pokud chcete vybrat značku pro konkrétní verzi, použijte rozevírací seznam pro přepnutí větví nebo značek. Další informace najdete v tématu Jak vybrat značku verze zdrojového kódu ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Kategorie protokolu na straně klienta

Podporují se kategorie protokolů.

Následující příklad ukazuje, jak používat kategorie protokolů s Counter komponentou aplikace vytvořené ze Blazor šablony projektu.

IncrementCount V metodě komponenty aplikace Counter (Counter.razor), která vloží jako ILoggerFactoryLoggerFactory:

var logger = LoggerFactory.CreateLogger("CustomCategory");
logger.LogWarning("Someone has clicked me!");

výstup konzoly Vývojářské nástroje:

warn: CustomCategory[0]
Someone has clicked me!

ID události protokolu na straně klienta

Podporuje se ID události protokolu.

Následující příklad ukazuje, jak používat ID událostí protokolu se Counter součástí aplikace vytvořené ze Blazor šablony projektu.

LogEvent.cs:

public class LogEvent
{
    public const int Event1 = 1000;
    public const int Event2 = 1001;
}

IncrementCount V metodě komponenty aplikace Counter (Counter.razor):

logger.LogInformation(LogEvent.Event1, "Someone has clicked me!");
logger.LogWarning(LogEvent.Event2, "Someone has clicked me!");

výstup konzoly Vývojářské nástroje:

info: BlazorSample.Pages.Counter[1000]
Someone has clicked me!
warn: BlazorSample.Pages.Counter[1001]
Someone has clicked me!

Šablona zprávy protokolu na straně klienta

Podporují se šablony zpráv protokolu:

Následující příklad ukazuje, jak používat šablony zpráv protokolu se Counter součástí aplikace vytvořené ze Blazor šablony projektu.

IncrementCount V metodě komponenty aplikace Counter (Counter.razor):

logger.LogInformation("Someone clicked me at {CurrentDT}!", DateTime.UtcNow);

výstup konzoly Vývojářské nástroje:

info: BlazorSample.Pages.Counter[0]
Someone clicked me at 04/21/2022 12:15:57!

Parametry výjimky protokolu na straně klienta

Podporují se parametry výjimek protokolu.

Následující příklad ukazuje, jak použít parametry výjimky protokolu s Counter komponentou aplikace vytvořené ze Blazor šablony projektu.

IncrementCount V metodě komponenty aplikace Counter (Counter.razor):

currentCount++;

try
{
    if (currentCount == 3)
    {
        currentCount = 4;
        throw new OperationCanceledException("Skip 3");
    }
}
catch (Exception ex)
{
    logger.LogWarning(ex, "Exception (currentCount: {Count})!", currentCount);
}

výstup konzoly Vývojářské nástroje:

warn: BlazorSample.Pages.Counter[0]
Exception (currentCount: 4)!
System.OperationCanceledException: Skip 3
at BlazorSample.Pages.Counter.IncrementCount() in C:UsersAlabaDesktopBlazorSamplePagesCounter.razor:line 28

Funkce filtru na straně klienta

Podporují se funkce filtru.

Následující příklad ukazuje, jak použít filtr se Counter součástí aplikace vytvořené ze Blazor šablony projektu.

V souboru Program:

builder.Logging.AddFilter((provider, category, logLevel) =>
    category.Equals("CustomCategory2") && logLevel == LogLevel.Information);

IncrementCount V metodě komponenty aplikace Counter (Counter.razor), která vloží jako ILoggerFactoryLoggerFactory:

var logger1 = LoggerFactory.CreateLogger("CustomCategory1");
logger1.LogInformation("Someone has clicked me!");

var logger2 = LoggerFactory.CreateLogger("CustomCategory1");
logger2.LogWarning("Someone has clicked me!");

var logger3 = LoggerFactory.CreateLogger("CustomCategory2");
logger3.LogInformation("Someone has clicked me!");

var logger4 = LoggerFactory.CreateLogger("CustomCategory2");
logger4.LogWarning("Someone has clicked me!");

Ve výstupu konzoly vývojářských nástrojů filtr povoluje protokolování pouze pro CustomCategory2 kategorii a Information zprávu na úrovni protokolu:

info: CustomCategory2[0]
Someone has clicked me!

Aplikace může také nakonfigurovat filtrování protokolů pro konkrétní obory názvů. Například nastavte úroveň protokolu na Trace v Program souboru:

builder.Logging.SetMinimumLevel(LogLevel.Trace);

Trace Výstup konzoly vývojářských nástrojů na úrovni protokolu obvykle zahrnuje Microsoft.AspNetCore.Components.RenderTree zprávy protokolování, například následující:

dbug: Microsoft.AspNetCore.Components.RenderTree.Renderer[3]
Rendering component 14 of type Microsoft.AspNetCore.Components.Web.HeadOutlet

Program V souboru je možné protokolování zpráv specifických pro Microsoft.AspNetCore.Components.RenderTree zakázání pomocí některého z následujících přístupů:

  • builder.Logging.AddFilter("Microsoft.AspNetCore.Components.RenderTree.*", LogLevel.None);

  • builder.Services.PostConfigure<LoggerFilterOptions>(options =>
    options.Rules.Add(
        new LoggerFilterRule(null, 
                             "Microsoft.AspNetCore.Components.RenderTree.*", 
                             LogLevel.None, 
                             null)
    ));

Po přidání některého z předchozích filtrů do aplikace se výstup konzoly na podrobné úrovni nezobrazí zprávy protokolování z Microsoft.AspNetCore.Components.RenderTree rozhraní API.

Vlastní zprostředkovatel protokolovacího nástroje na straně klienta

Příklad v této části ukazuje vlastního zprostředkovatele protokolovacího nástroje pro další přizpůsobení.

Přidejte do aplikace Microsoft.Extensions.Logging.Configuration odkaz na balíček.

Poznámka:

Pokyny k přidávání balíčků do aplikací .NET najdete v článcích v části Instalace a správa balíčků na webu Pracovní postup používání balíčků (dokumentace k NuGetu). Ověřte správné verze balíčků na NuGet.org.

Přidejte následující vlastní konfiguraci protokolovacího nástroje. Konfigurace vytvoří LogLevels slovník, který nastaví vlastní formát protokolu pro tři úrovně protokolu: Information, Warninga Error. A LogFormatenum slouží k popisu krátkých (LogFormat.Short) a dlouhých (LogFormat.Long) formátů.

CustomLoggerConfiguration.cs:

using Microsoft.Extensions.Logging;

public class CustomLoggerConfiguration
{
    public int EventId { get; set; }

    public Dictionary<LogLevel, LogFormat> LogLevels { get; set; } = 
        new()
        {
            [LogLevel.Information] = LogFormat.Short,
            [LogLevel.Warning] = LogFormat.Short,
            [LogLevel.Error] = LogFormat.Long
        };

    public enum LogFormat
    {
        Short,
        Long
    }
}

Do aplikace přidejte následující vlastní protokolovací nástroj. Výstupy CustomLogger vlastní formáty protokolů založené na logLevel hodnotách definovaných v předchozí CustomLoggerConfiguration konfiguraci.

using Microsoft.Extensions.Logging;
using static CustomLoggerConfiguration;

public sealed class CustomLogger : ILogger
{
    private readonly string name;
    private readonly Func<CustomLoggerConfiguration> getCurrentConfig;

    public CustomLogger(
        string name,
        Func<CustomLoggerConfiguration> getCurrentConfig) =>
        (this.name, this.getCurrentConfig) = (name, getCurrentConfig);

    public IDisposable BeginScope<TState>(TState state) => default!;

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

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

        CustomLoggerConfiguration config = getCurrentConfig();

        if (config.EventId == 0 || config.EventId == eventId.Id)
        {
            switch (config.LogLevels[logLevel])
            {
                case LogFormat.Short:
                    Console.WriteLine($"{name}: {formatter(state, exception)}");
                    break;
                case LogFormat.Long:
                    Console.WriteLine($"[{eventId.Id, 2}: {logLevel, -12}] {name} - {formatter(state, exception)}");
                    break;
                default:
                    // No-op
                    break;
            }
        }
    }
}

Do aplikace přidejte následujícího zprostředkovatele vlastního protokolovacího nástroje. CustomLoggerProviderOptionspřijímá přístup založený na konfiguraci protokolovacího nástroje prostřednictvím integrovaných konfiguračních funkcí protokolování. Aplikace může například nastavit nebo změnit formáty protokolu prostřednictvím appsettings.json souboru, aniž by vyžadovala změny kódu vlastního protokolovacího nástroje, což je znázorněno na konci této části.

CustomLoggerProvider.cs:

using System.Collections.Concurrent;
using Microsoft.Extensions.Options;

[ProviderAlias("CustomLog")]
public sealed class CustomLoggerProvider : ILoggerProvider
{
    private readonly IDisposable onChangeToken;
    private CustomLoggerConfiguration config;
    private readonly ConcurrentDictionary<string, CustomLogger> loggers =
        new(StringComparer.OrdinalIgnoreCase);

    public CustomLoggerProvider(
        IOptionsMonitor<CustomLoggerConfiguration> config)
    {
        this.config = config.CurrentValue;
        onChangeToken = config.OnChange(updatedConfig => this.config = updatedConfig);
    }

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

    private CustomLoggerConfiguration GetCurrentConfig() => config;

    public void Dispose()
    {
        loggers.Clear();
        onChangeToken.Dispose();
    }
}

Přidejte následující vlastní rozšíření protokolovacího nástroje.

CustomLoggerExtensions.cs:

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

public static class CustomLoggerExtensions
{
    public static ILoggingBuilder AddCustomLogger(
        this ILoggingBuilder builder)
    {
        builder.AddConfiguration();

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

        LoggerProviderOptions.RegisterProviderOptions
            <CustomLoggerConfiguration, CustomLoggerProvider>(builder.Services);

        return builder;
    }
}

Program V souboru v tvůrci hostitelů vymažte existujícího zprostředkovatele voláním ClearProviders a přidáním vlastního zprostředkovatele protokolování:

builder.Logging.ClearProviders().AddCustomLogger();

V následující komponentě CustomLoggerExample:

  • Zpráva ladění není zaprotokolována.
  • Informační zpráva je protokolována v krátkém formátu (LogFormat.Short).
  • Zpráva upozornění se protokoluje ve krátkém formátu (LogFormat.Short).
  • Chybová zpráva se protokoluje v dlouhém formátu (LogFormat.Long).
  • Zpráva trasování se nezaprotokoluje.

CustomLoggerExample.razor:

@page "/custom-logger-example"
@inject ILogger<CustomLoggerExample> Logger

<p>
    <button @onclick="LogMessages">Log Messages</button>
</p>

@code{
    private void LogMessages()
    {
        Logger.LogDebug(1, "This is a debug message.");
        Logger.LogInformation(3, "This is an information message.");
        Logger.LogWarning(5, "This is a warning message.");
        Logger.LogError(7, "This is an error message.");
        Logger.LogTrace(5!, "This is a trace message.");
    }
}

@page "/custom-logger-example"
@using Microsoft.Extensions.Logging
@inject ILogger<CustomLoggerExample> Logger

<p>
    <button @onclick="LogMessages">Log Messages</button>
</p>

@code{
    private void LogMessages()
    {
        Logger.LogDebug(1, "This is a debug message.");
        Logger.LogInformation(3, "This is an information message.");
        Logger.LogWarning(5, "This is a warning message.");
        Logger.LogError(7, "This is an error message.");
        Logger.LogTrace(5!, "This is a trace message.");
    }
}

Následující výstup se zobrazí v konzole vývojářských nástrojů prohlížeče, když Log Messages je tlačítko vybrané. Položky protokolu odpovídají příslušným formátům použitým vlastním protokolovacím nástrojem (klientská aplikace má název LoggingTest):

LoggingTest.Pages.CustomLoggerExample: This is an information message.
LoggingTest.Pages.CustomLoggerExample: This is a warning message.
[ 7: Error ] LoggingTest.Pages.CustomLoggerExample - This is an error message.

Z neformální kontroly předchozího příkladu je zřejmé, že nastavení formátů řádků protokolu prostřednictvím slovníku CustomLoggerConfiguration není nezbytně nutné. Formáty řádků použité vlastním protokolovacím nástrojem (CustomLogger) mohly být použity pouze kontrolou logLevel metody Log . Účelem přiřazení formátu protokolu prostřednictvím konfigurace je, že vývojář může snadno změnit formát protokolu prostřednictvím konfigurace aplikace, jak ukazuje následující příklad.

V aplikaci na straně klienta přidejte nebo aktualizujte appsettings.json soubor tak, aby zahrnoval konfiguraci protokolování. Nastavte formát protokolu na Long všechny tři úrovně protokolu:

{
  "Logging": {
    "CustomLog": {
      "LogLevels": {
        "Information": "Long",
        "Warning": "Long",
        "Error": "Long"
      }
    }
  }
}

V předchozím příkladu si všimněte, že položka pro vlastní konfiguraci protokolovacího nástroje je CustomLog, která byla použita pro vlastního zprostředkovatele protokolovacího nástroje (CustomLoggerProvider) jako alias s [ProviderAlias("CustomLog")]. Konfigurace protokolování mohla být použita s názvem CustomLoggerProvider místo CustomLog, ale použití aliasu CustomLog je uživatelsky přívětivější.

Program V souboru spotřebujte konfiguraci protokolování. Přidejte následující kód:

builder.Logging.AddConfiguration(
    builder.Configuration.GetSection("Logging"));

Volání LoggingBuilderConfigurationExtensions.AddConfiguration lze umístit buď před nebo po přidání vlastního zprostředkovatele protokolovacího nástroje.

Spusťte aplikaci znovu. Vyberte tlačítko Log Messages. Všimněte si, že konfigurace protokolování se použije ze appsettings.json souboru. Všechny tři položky protokolu jsou v dlouhém formátu (LogFormat.Long) (klientská aplikace má název LoggingTest):

[ 3: Information ] LoggingTest.Pages.CustomLoggerExample - This is an information message.
[ 5: Warning ] LoggingTest.Pages.CustomLoggerExample - This is a warning message.
[ 7: Error ] LoggingTest.Pages.CustomLoggerExample - This is an error message.

Obory protokolů na straně klienta

Protokolovací nástroj konzoly vývojářských nástrojů nepodporuje obory protokolů. Vlastní protokolovací nástroj však může podporovat obory protokolů. Nepodporovaný příklad, který můžete dále vyvíjet tak, aby vyhovoval vašim potřebám, najdete BlazorWebAssemblyScopesLogger v ukázkové aplikaci v Blazor úložišti GitHub s ukázkami (jak si ji stáhnout).

Ukázková aplikace používá standardní syntaxi protokolování ASP.NET Core BeginScope k označení oborů pro protokolované zprávy. Služba Logger v následujícím příkladu je , ILogger<CustomLoggerExample>která se vloží do komponenty aplikace CustomLoggerExample (CustomLoggerExample.razor).

using (Logger.BeginScope("L1"))
{
    Logger.LogInformation(3, "INFO: ONE scope.");
}

using (Logger.BeginScope("L1"))
{
    using (Logger.BeginScope("L2"))
    {
        Logger.LogInformation(3, "INFO: TWO scopes.");
    }
}

using (Logger.BeginScope("L1"))
{
    using (Logger.BeginScope("L2"))
    {
        using (Logger.BeginScope("L3"))
        {
            Logger.LogInformation(3, "INFO: THREE scopes.");
        }
    }
}

Výstup:

[ 3: Informace ] {CLASS} – INFORMACE: JEDEN OBOR. => L1 blazor.webassembly.js:1:35542
[ 3: Informace ] {CLASS} – INFORMACE: DVA OBORY. = L1 =>> L2 blazor.webassembly.js:1:35542
[ 3: Informace ] {CLASS} – INFORMACE: TŘI obory. = L1 =>> L2 => L3

Zástupný {CLASS} symbol v předchozím příkladu je BlazorWebAssemblyScopesLogger.Pages.CustomLoggerExample.

Protokolování předem vyřazovaných komponent

Předenderované komponenty spouští kód inicializace komponent dvakrát. Protokolování probíhá na straně serveru při prvním spuštění inicializačního kódu a na straně klienta při druhém spuštění inicializačního kódu. V závislosti na cíli protokolování během inicializace zkontrolujte protokoly na straně serveru, na straně klienta nebo na obou.

SignalR protokolování klienta pomocí SignalR tvůrce klienta

Tato část se týká aplikací na straně serveru.

V Blazor konfiguraci spuštění skriptu předejte configureSignalR objekt konfigurace, který volá configureLogging úroveň protokolu.

configureLogging Pro hodnotu úrovně protokolu předejte argument jako řetězec nebo celočíselnou úroveň protokolu zobrazenou v následující tabulce.

LogLevel Nastavení řetězce Celočíselné nastavení
Trace trace 0
Debug debug 1
Information information 2
Warning warning 3
Error error 4
Critical critical 5
None none 6

Příklad 1: Nastavte Information úroveň protokolu s řetězcovou hodnotou.

Blazor Webová aplikace:

<script src="{BLAZOR SCRIPT}" autostart="false"></script>
<script>
  Blazor.start({
    circuit: {
      configureSignalR: function (builder) {
        builder.configureLogging("information");
      }
    }
  });
</script>

Blazor Server:

<script src="{BLAZOR SCRIPT}" autostart="false"></script>
<script>
  Blazor.start({
    configureSignalR: function (builder) {
      builder.configureLogging("information");
    }
  });
</script>

V předchozím příkladu {BLAZOR SCRIPT} je Blazor zástupný symbol cesta ke skriptu a název souboru. Umístění skriptu najdete v tématu ASP.NET Blazor Základní struktura projektu.

Příklad 2: Nastavte Information úroveň protokolu celočíselnou hodnotou.

Blazor Webová aplikace:

<script src="{BLAZOR SCRIPT}" autostart="false"></script>
<script>
  Blazor.start({
    circuit: {
      configureSignalR: function (builder) {
        builder.configureLogging(2); // LogLevel.Information
      }
    }
  });
</script>

Blazor Server:

<script src="{BLAZOR SCRIPT}" autostart="false"></script>
<script>
  Blazor.start({
    configureSignalR: function (builder) {
      builder.configureLogging(2); // LogLevel.Information
    }
  });
</script>

V předchozím příkladu {BLAZOR SCRIPT} je Blazor zástupný symbol cesta ke skriptu a název souboru. Umístění skriptu najdete v tématu ASP.NET Blazor Základní struktura projektu.

Poznámka:

Použití celočíselného čísla k určení úrovně protokolování v příkladu 2, často označované jako magické číslo nebo magická konstanta, je považováno za špatnou programovací praxi, protože celé číslo při prohlížení zdrojového kódu jasně neidentifikuje úroveň protokolování. Pokud je priorita minimalizace bajtů přenesených do prohlížeče, může být použití celého čísla odůvodněné (v takových případech zvažte odebrání komentáře).

Další informace o Blazor spuštění (Blazor.start()) najdete v tématu ASP.NET Spuštění CoreBlazor.

SignalR protokolování klienta pomocí konfigurace aplikace

Nastavte konfiguraci nastavení aplikace, jak je popsáno v konfiguraci ASP.NET CoreBlazor. Umístěte soubory nastavení aplikace, wwwroot které obsahují Logging:LogLevel:HubConnection nastavení aplikace.

Poznámka:

Jako alternativu k použití nastavení aplikace můžete předat LogLevel jako argument, ke které LoggingBuilderExtensions.SetMinimumLevel se použije připojení centra v komponentě Razor . Náhodné nasazení aplikace do produkčního hostitelského prostředí s podrobným protokolováním ale může způsobit snížení výkonu. K nastavení úrovně protokolu doporučujeme použít nastavení aplikace.

Logging:LogLevel:HubConnection Zadejte nastavení aplikace ve výchozím appsettings.json souboru a v Development souboru nastavení aplikace prostředí. Pro výchozí nastavení použijte typickou méně podrobnou úroveň protokolu, například LogLevel.Warning. Výchozí hodnota nastavení aplikace je to, co se používá v Staging prostředích, Production pokud nejsou k dispozici žádné soubory nastavení aplikace pro tato prostředí. V souboru nastavení aplikace prostředí použijte podrobnou úroveň Development protokolu, například LogLevel.Trace.

wwwroot/appsettings.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
      "HubConnection": "Warning"
    }
  }
}

wwwroot/appsettings.Development.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
      "HubConnection": "Trace"
    }
  }
}

Důležité

Konfigurace v předchozích souborech nastavení aplikace se používá jenom v případě, že se použijí pokyny v konfiguraci ASP.NET CoreBlazor.

V horní části Razor souboru komponenty (.razor):

  • Vložte do ILoggerProvider zprostředkovatele protokolování předaného WebAssemblyConsoleLoggerHubConnectionBuilderdo souboru . Na rozdíl od , ConsoleLoggerProviderWebAssemblyConsoleLogger je obálka kolem rozhraní API protokolování specifické pro prohlížeč (například console.log). WebAssemblyConsoleLogger Použití protokolování umožňuje v rámci Mono v kontextu prohlížeče.
  • Vložením souboru IConfiguration pro čtení Logging:LogLevel:HubConnection nastavení aplikace

Poznámka:

WebAssemblyConsoleLogger je interní a nepodporuje přímé použití v kódu vývojáře.

@inject ILoggerProvider LoggerProvider
@inject IConfiguration Config

Poznámka:

Následující příklad vychází z ukázky SignalRBlazor v kurzu. Další podrobnosti najdete v tomto kurzu.

V metodě komponenty OnInitializedAsync použijte HubConnectionBuilderExtensions.ConfigureLogging k přidání zprostředkovatele protokolování a nastavení minimální úrovně protokolu z konfigurace:

protected override async Task OnInitializedAsync()
{
    hubConnection = new HubConnectionBuilder()
        .WithUrl(Navigation.ToAbsoluteUri("/chathub"))
        .ConfigureLogging(builder => 
        {
            builder.AddProvider(LoggerProvider);
            builder.SetMinimumLevel(
                Config.GetValue<LogLevel>("Logging:LogLevel:HubConnection"));
        })
        .Build();

    hubConnection.On<string, string>("ReceiveMessage", (user, message) => ...

    await hubConnection.StartAsync();
}

Poznámka:

V předchozím příkladu Navigation je vložena NavigationManager.

Další informace o nastavení prostředí aplikace najdete v tématu ASP.NET prostředí CoreBlazor.

Protokolování ověřování na straně klienta

Protokolujte Blazor ověřovací zprávy na úrovních LogLevel.Debug nebo LogLevel.Trace protokolování s konfigurací protokolování v nastavení aplikace nebo pomocí filtru protokolu pro Microsoft.AspNetCore.Components.WebAssembly.Authentication soubor Program .

Použijte některý z následujících přístupů:

  • V souboru nastavení aplikace (například wwwroot/appsettings.Development.json):

    "Logging": {
  "LogLevel": {
    "Microsoft.AspNetCore.Components.WebAssembly.Authentication": "Debug"
  }
}

    Další informace o tom, jak nakonfigurovat aplikaci na straně klienta ke čtení souborů nastavení aplikace, najdete v tématu ASP.NET Základní Blazor konfigurace.

  • Pomocí filtru protokolu použijte následující příklad:

    • Aktivuje protokolování konfigurace Debug sestavení pomocí direktivy preprocesoru jazyka C#.
    • Protokoluje Blazor ověřovací zprávy na Debug úrovni protokolu.
    #if DEBUG
    builder.Logging.AddFilter(
        "Microsoft.AspNetCore.Components.WebAssembly.Authentication", 
        LogLevel.Debug);
#endif

Poznámka:

Razorkomponenty vykreslené v klientovi se protokolují pouze do konzoly vývojářských nástrojů prohlížeče na straně klienta.

Další materiály