ASP.NET Registro em log principal Blazor

Este artigo explica o Blazor registo em log da aplicação, incluindo a configuração e como registar mensagens de log a partir de Razor componentes.

Configuration

A configuração de registo pode ser carregada a partir de ficheiros de configurações da aplicação. Para obter mais informações, consulte configuração do ASP.NET Core Blazor.

Nos níveis de log padrão e sem configurar provedores de log adicionais:

• No servidor, o registo ocorre apenas no console .NET do servidor no ambiente Development, no nível LogLevel.Information ou superior.
• No cliente, o registo ocorre apenas no console de ferramentas de desenvolvimento do navegador no nível ou superior.

Quando a aplicação é configurada no arquivo de projeto para usar namespaces implícitos (<ImplicitUsings>enable</ImplicitUsings>), uma using diretiva para Microsoft.Extensions.Logging ou qualquer API na LoggerExtensions classe não é necessária para suportar a conclusão de API do Visual Studio IntelliSense ou a compilação de aplicações. Se os namespaces implícitos não estiverem habilitados, Razor os componentes devem definir diretivas de @using explicitamente para logar namespaces que não são importados através do arquivo _Imports.razor.

Níveis de registo

Os níveis de log estão de acordo com os níveis de log da app ASP.NET Core, listados na documentação da API em LogLevel.

Razor registro de componentes

O exemplo a seguir:

• Injeta um ILogger objeto (ILogger<Counter1>) para criar um registrador. A categoria do log é o nome totalmente qualificado do tipo do componente, Counter.
• Chama LogWarning para registar ao Warning nível.

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

O exemplo a seguir demonstra o registro em log com um ILoggerFactory em componentes.

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

Registo de logs no servidor

Para obter orientações gerais sobre o registo no ASP.NET Core, consulte Registo no .NET e no ASP.NET Core.

Registo do lado do cliente

Nem todos os recursos do log do ASP.NET Core são suportados no lado do cliente. Por exemplo, os componentes do lado do cliente não têm acesso ao sistema de arquivos ou à rede do cliente, portanto, gravar logs no armazenamento físico ou de rede do cliente não é possível. Ao usar um serviço de log de terceiros projetado para funcionar com aplicativos de página única (SPAs), siga as diretrizes de segurança do serviço. Tenha em mente que todos os dados, incluindo chaves ou segredos armazenados no lado do cliente, são inseguros e podem ser facilmente descobertos por usuários mal-intencionados.

Configure o registo de logs em aplicações no lado do cliente com a propriedade WebAssemblyHostBuilder.Logging. A propriedade Logging é do tipo ILoggingBuilder, portanto, os métodos de extensão de ILoggingBuilder são suportados.

Para definir o nível mínimo de log, chame LoggingBuilderExtensions.SetMinimumLevel o construtor de hosts no Program arquivo com o LogLevel. O exemplo a seguir define o nível mínimo de log como Warning:

builder.Logging.SetMinimumLevel(LogLevel.Warning);

Fazer login no arquivo do lado Program do cliente

O registo de logs é suportado em aplicativos do lado cliente após WebAssemblyHostBuilder ser construído usando o fornecedor de registo de logs de consola interno da estrutura (WebAssemblyConsoleLoggerProvider (fonte de referência)).

No ficheiro 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();

Saída do console de ferramentas de desenvolvedor

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

Note

Os links de documentação para a fonte de referência do .NET geralmente carregam a ramificação padrão do repositório, que representa o desenvolvimento atual para a próxima versão do .NET. Para selecionar uma tag para uma versão específica, use a lista suspensa Alternar entre ramificações ou tags. Para obter mais informações, consulte Como selecionar uma marca de versão do código-fonte ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Categoria de log do lado do cliente

As categorias de log são suportadas.

O exemplo a seguir mostra como usar categorias de log com o Counter componente de um aplicativo criado a partir de um Blazor modelo de projeto.

No método do componente da aplicação IncrementCount (Counter), que injeta um Counter.razor como ILoggerFactory:

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

Saída do console de ferramentas de desenvolvedor

warn: CustomCategory[0]
Someone has clicked me!

ID do evento de log do lado do cliente

A ID do evento de log é suportada.

O exemplo a seguir mostra como usar IDs de evento de log no Counter componente de uma aplicação criada a partir de um Blazor modelo de projeto.

LogEvent.cs:

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

IncrementCount No método do componente do Counter aplicativo (Counter.razor):

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

Saída do console de ferramentas de desenvolvedor

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

Modelo de mensagem de log do lado do cliente

Os modelos de mensagens de log são suportados:

O exemplo a seguir mostra como usar modelos de mensagem de registo com o componente Counter de uma aplicação criada a partir de um modelo de projeto Blazor.

IncrementCount No método do componente do Counter aplicativo (Counter.razor):

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

Saída do console de ferramentas de desenvolvedor

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

Parâmetros de exceção do log no lado do cliente

Os parâmetros de exceção de log são suportados.

O exemplo a seguir mostra como usar parâmetros de exceção de log com o Counter componente de um aplicativo criado a partir de um Blazor modelo de projeto.

IncrementCount No método do componente do Counter aplicativo (Counter.razor):

currentCount++;

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

Saída do console de ferramentas de desenvolvedor

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

Função de filtro do lado do cliente

As funções de filtro são suportadas.

O exemplo a seguir mostra como usar um filtro com o Counter componente de um aplicativo criado a partir de um Blazor modelo de projeto.

No ficheiro Program:

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

No método do componente da aplicação IncrementCount (Counter), que injeta um Counter.razor como ILoggerFactory:

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!");

Na saída do console das ferramentas de desenvolvedor, o filtro só permite o registo em log para a categoria CustomCategory2 e nível de log Information.

info: CustomCategory2[0]
Someone has clicked me!

O aplicativo também pode configurar a filtragem de log para namespaces específicos. Por exemplo, defina o nível de log para Trace no ficheiro Program.

builder.Logging.SetMinimumLevel(LogLevel.Trace);

Normalmente, no Trace nível de log, a saída do console das ferramentas de desenvolvedor no nível Verbose inclui Microsoft.AspNetCore.Components.RenderTree mensagens de log, como as seguintes:

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

No arquivo, o Program registro de mensagens específicas para Microsoft.AspNetCore.Components.RenderTree pode ser desabilitado usando uma das seguintes abordagens:

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

Depois de adicionar qualquer um dos filtros anteriores ao aplicativo, a saída do console no nível de verbosidade não mostra mensagens de log da API.

Provedor de logger personalizado do lado do cliente

O exemplo nesta seção demonstra um provedor de logger personalizado para personalização adicional.

Adicione uma referência de pacote à aplicação para o pacote Microsoft.Extensions.Logging.Configuration.

Note

Para obter orientação sobre como adicionar pacotes a aplicativos .NET, consulte os artigos na seção Instalar e gerenciar pacotes em Workflow de utilização de pacotes (documentação do NuGet). Confirme as versões corretas do pacote em NuGet.org.

Adicione a seguinte configuração de logger personalizado. A configuração estabelece um LogLevels dicionário que define um formato de log personalizado para três níveis de log: Information, Warninge Error. A LogFormatenum é usado para descrever formatos curtos (LogFormat.Short) e longos (LogFormat.Long).

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

Adicione o seguinte registador personalizado à aplicação. O CustomLogger produz formatos de log personalizados com base nos valores logLevel definidos na configuração CustomLoggerConfiguration anterior.

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

Adicione o seguinte provedor de logger personalizado ao aplicativo. CustomLoggerProvider Adota uma Optionsabordagem baseada em log para configurar o registrador por meio de recursos internos de configuração de log. Por exemplo, o aplicativo pode definir ou alterar formatos de log por meio de um appsettings.json arquivo sem exigir alterações de código no registrador personalizado, o que é demonstrado no final desta seção.

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

Adicione as seguintes extensões de logger personalizadas.

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

No ficheiro do host builder, limpe o provedor existente chamando Program e adicione o provedor de log personalizado:

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

No componente seguinte CustomLoggerExample:

• A mensagem de depuração não é registrada.
• A mensagem informativa é registada em formato abreviado (LogFormat.Short).
• A mensagem de aviso é registada no formato curto (LogFormat.Short).
• A mensagem de erro é registrada no formato longo (LogFormat.Long).
• A mensagem de rastreamento não é registrada.

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

A seguinte saída é exibida na consola das ferramentas de desenvolvimento do navegador quando o botão Log Messages é selecionado. As entradas de log refletem os formatos apropriados aplicados pelo registrador personalizado (o aplicativo cliente é chamado 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.

A partir de uma inspeção casual do exemplo anterior, é evidente que não é estritamente necessário definir os formatos de linha de log através do dicionário em CustomLoggerConfiguration. Os formatos de linha aplicados pelo registrador personalizado (CustomLogger) poderiam ter sido aplicados bastando verificar o logLevel no método Log. O objetivo de atribuir o formato de log via configuração é que o desenvolvedor pode alterar o formato de log facilmente por meio da configuração do aplicativo, como demonstra o exemplo a seguir.

No aplicativo do lado do cliente, adicione ou atualize o arquivo appsettings.json para incluir a configuração de registo. Defina o formato de log para Long para todos os três níveis de log:

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

No exemplo anterior, observe que a entrada para a configuração do logger personalizado é CustomLog, que foi aplicada ao provedor de logger personalizado (CustomLoggerProvider) como um alias com [ProviderAlias("CustomLog")]. A configuração de log poderia ter sido aplicada com o nome CustomLoggerProvider em vez de CustomLog, mas o uso do alias CustomLog é mais amigável.

No arquivo Program, consuma a configuração de log. Adicione o seguinte código:

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

A chamada para LoggingBuilderConfigurationExtensions.AddConfiguration pode ser feita antes ou depois de adicionar o provedor de logger personalizado.

Execute o aplicativo novamente. Selecione o botão Log Messages. Observe que a configuração de log é aplicada a partir do appsettings.json arquivo. Todas as três entradas de log estão no formato longo (LogFormat.Long) (o aplicativo cliente é chamado 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.

Escopos de log do lado do cliente

O logger do console das ferramentas de desenvolvedor não oferece suporte a escopos de log. No entanto, um registrador personalizado pode oferecer suporte a escopos de log. Para obter um exemplo sem suporte que você pode desenvolver ainda mais para atender às suas necessidades, consulte o BlazorWebAssemblyScopesLogger aplicativo de exemplo no Blazor repositório GitHub de exemplos (como fazer o download).

O aplicativo de exemplo usa a sintaxe padrão de log do ASP.NET Core BeginScope para indicar escopos para mensagens registradas. O Logger serviço no exemplo a seguir é um ILogger<CustomLoggerExample>, que é injetado no componente CustomLoggerExample da aplicação (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.");
        }
    }
}

Output:

[ 3: Informação ] {CLASS} - INFO: Um âmbito. => L1 blazor.webassembly.js:1:35542
[ 3: Informação ] {CLASS} - INFO: DOIS escopos. => L1 => L2 blazor.webassembly.js:1:35542
[ 3: Informação ] {CLASS} - INFO: TRÊS âmbitos. => L1 => L2 => L3

O {CLASS} marcador no exemplo anterior é BlazorWebAssemblyScopesLogger.Pages.CustomLoggerExample.

Registro de logs de componentes pré-renderizados

Os componentes pré-renderizados executam o código de inicialização do componente duas vezes. O registro em log ocorre no lado do servidor na primeira execução do código de inicialização e no lado do cliente na segunda execução do código de inicialização. Dependendo do objetivo do registro em log durante a inicialização, verifique os logs do lado do servidor, do lado do cliente ou de ambos.

SignalR Registro de cliente com o construtor de SignalR clientes

Esta secção aplica-se a aplicações do lado do servidor.

Na Blazor configuração de início de script, passe o objeto de configuração configureSignalR que chama configureLogging com o nível de log.

Para o valor do configureLogging nível de log, passe o argumento como texto ou como número inteiro do nível de log indicado na tabela abaixo.

LogLevel	Configuração das cordas	Configuração inteira
Trace	trace	0
Debug	debug	1
Information	information	2
Warning	warning	3
Error	error	4
Critical	critical	5
None	none	6

Exemplo 1: Defina o nível de Information log com um valor de string.

Blazor Web App:

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

No exemplo anterior, o marcador {BLAZOR SCRIPT} é o caminho de script Blazor e o nome do ficheiro. Para consultar a localização do script, veja a estrutura do projeto do ASP.NET Core Blazor.

Exemplo 2: Defina o nível de Information log com um valor inteiro.

Blazor Web App:

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

No exemplo anterior, o marcador {BLAZOR SCRIPT} é o caminho de script Blazor e o nome do ficheiro. Para consultar a localização do script, veja a estrutura do projeto do ASP.NET Core Blazor.

Note

Usar um inteiro para especificar o nível de log no Exemplo 2, muitas vezes referido como um número mágico ou constante mágica, é considerado uma prática de codificação ruim porque o inteiro não identifica claramente o nível de log ao visualizar o código-fonte. Se minimizar os bytes transferidos para o navegador for uma prioridade, o uso de um inteiro pode ser justificado (considere remover o comentário nesses casos).

Para obter mais informações sobre Blazor inicialização (Blazor.start()), consulte ASP.NET inicialização principalBlazor.

SignalR Registo do cliente com configuração da aplicação

Configure a configuração das definições da aplicação conforme descrito na configuração ASP.NET CoreBlazor. Coloque os ficheiros de definições da aplicação em wwwroot que contenham uma definição de aplicação Logging:LogLevel:HubConnection.

Note

Como alternativa ao uso das configurações do aplicativo, pode passar o LogLevel como argumento para LoggingBuilderExtensions.SetMinimumLevel quando a conexão de hub é criada num componente Razor. No entanto, a implantação acidental do aplicativo em um ambiente de hospedagem de produção com registro detalhado pode resultar em uma penalidade de desempenho. Recomendamos o uso das configurações do aplicativo para definir o nível de log.

Forneça uma configuração de aplicativo Logging:LogLevel:HubConnection no arquivo padrão appsettings.json e no arquivo de configurações de aplicativo do ambiente Development. Use um nível de log menos detalhado típico como padrão, tal como LogLevel.Warning. O valor de configurações padrão do aplicativo é o que é usado em Staging e Production ambientes se nenhum arquivo de configurações do aplicativo para esses ambientes estiver presente. Use um nível de log detalhado no ficheiro de definições do ambiente da aplicação Development, tal como 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"
    }
  }
}

Important

A configuração nos arquivos de configurações do aplicativo anterior só é usada pelo aplicativo se as orientações na configuração ASP.NET Core Blazor forem seguidas.

Na parte superior do arquivo do componente Razor (.razor):

• Injete um ILoggerProvider para adicionar um WebAssemblyConsoleLogger aos provedores de log passados para HubConnectionBuilder. Ao contrário de um ConsoleLoggerProvider, WebAssemblyConsoleLogger é um wrapper em torno de APIs de log específicas do navegador (por exemplo, console.log). O uso de WebAssemblyConsoleLogger torna possível o registo no Mono num contexto de navegador.
• Injete um IConfiguration para ler a configuração do Logging:LogLevel:HubConnection aplicativo.

Note

WebAssemblyConsoleLogger é interno e não é suportado para uso direto no código do desenvolvedor.

@inject ILoggerProvider LoggerProvider
@inject IConfiguration Config

Note

O exemplo a seguir é baseado na demonstração no tutorial SignalRcom Blazor. Consulte o tutorial para obter mais detalhes.

No método OnInitializedAsync do componente, use HubConnectionBuilderExtensions.ConfigureLogging para adicionar o fornecedor de registo e definir o nível mínimo de registo a partir da configuração.

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

Note

No exemplo anterior, Navigation é uma injeção de NavigationManager.

Para obter mais informações sobre como definir o ambiente do aplicativo, consulte ASP.NET ambientes principaisBlazor.

Log de autenticação do lado do cliente

Registe mensagens de autenticação nos níveis de log Blazor ou LogLevel.Debug com uma configuração de log nas configurações da aplicação ou usando um filtro de log para LogLevel.Trace no arquivo Microsoft.AspNetCore.Components.WebAssembly.Authentication.

Use qualquer uma das seguintes abordagens:

• Em um arquivo de configurações do aplicativo (por exemplo, wwwroot/appsettings.Development.json):

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

  Para obter mais informações sobre como configurar um aplicativo do lado do cliente para ler arquivos de configurações do aplicativo, consulte Configuração ASP.NET CoreBlazor.

• Usando um filtro de log, o seguinte exemplo:

  • Ativa o registo para a configuração de build Debug usando uma diretiva de pré-processador C#.
  • Regista mensagens de autenticação ao nível de log BlazorDebug.

  #if DEBUG
      builder.Logging.AddFilter(
          "Microsoft.AspNetCore.Components.WebAssembly.Authentication", 
          LogLevel.Debug);
  #endif
  

Note

Razor Os componentes renderizados no cliente registram somente no console de ferramentas de desenvolvedor do navegador do lado do cliente.

Recursos adicionais

• Efetuando login no .NET e no ASP.NET Core
• Loglevel Enum (documentação da API)
• Implementar um provedor de log personalizado no .NET
• Documentação das ferramentas de desenvolvedor do navegador:
  • Ferramentas de desenvolvimento do Chrome
  • Visão geral das Ferramentas de Desenvolvedor do Microsoft Edge
• Blazor exemplos de repositório GitHub (dotnet/blazor-samples) (como fazer o download)