Protokolování ASP.NET Core Blazor
Poznámka:
Toto není nejnovější verze tohoto článku. Aktuální verzi najdete ve verzi .NET 8 tohoto článku.
Upozorňující
Tato verze ASP.NET Core se už nepodporuje. Další informace najdete v tématu .NET a .NET Core Zásady podpory. 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í:
- Na serveru se protokolování provádí pouze v konzole .NET na straně serveru v
Development
prostředí na LogLevel.Information úrovni nebo vyšší. - V klientovi se protokolování provádí pouze v konzole vývojářských nástrojů prohlížeče na straně klienta na LogLevel.Information úrovni nebo vyšší.
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.Logging Program
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 ILoggerFactory LoggerFactory
:
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 ILoggerFactory LoggerFactory
:
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 LogFormat
enum
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. CustomLoggerProvider
Options
př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
WebAssemblyConsoleLogger
HubConnectionBuilderdo souboru . Na rozdíl od , ConsoleLoggerProviderWebAssemblyConsoleLogger
je obálka kolem rozhraní API protokolování specifické pro prohlížeč (napříkladconsole.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 SignalR Blazor 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
- Aktivuje protokolování konfigurace
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
- Protokolování v .NET Core a ASP.NET Core
Loglevel
Výčet (dokumentace k rozhraní API)- Implementace vlastního zprostředkovatele protokolování v .NET
- Dokumentace k vývojářským nástrojům prohlížeče:
- Blazorukázky úložiště GitHub () (
dotnet/blazor-samples
postup stažení)