Back-End

26 fev, 2019

ASP .NET Core: apresentando e usando o Logging – Parte 01

Publicidade

Hoje veremos como funciona e como usar o Logging da ASP .NET Core.

O registro em log é um recurso essencial em aplicativos para detectar ou investigar problemas.

A ASP.NET Core dá suporte a uma API de Logging ou registro de atividades em log que funciona com uma variedade de provedores de logs.

Os provedores internos permitem que você envie logs para um ou mais destinos e você pode se conectar a uma estrutura de registros de log de terceiros como Log4Net, NLog e Elmah.

As interfaces e classes internas disponíveis para criação de log estão presentes no namespace Microsoft.Extensions.Logging, e são:

  • ILoggingFactory
  • ILoggingProvider
  • ILogger
  • LoggingFactory

A figura abaixo mostra o relacionamento entre as classes de logging:

ILoggerFactory

É uma factory interface para criar uma instância apropriada do tipo ILogger e também para adicionar uma instância ILoggerProvider.

public interface ILoggerFactory : IDisposable
{
    ILogger CreateLogger(string categoryName);
    void AddProvider(ILoggerProvider provider);
}

ILoggerProvider

Gerencia e cria o registrador apropriado especificado pela categoria de registro.

public interface ILoggerProvider : IDisposable
{
   ILogger CreateLogger(string categoryName);
}

Podemos criar nosso próprio provedor de logging implementando essa interface.

ILooger

Disponível no namespace Microsoft.Extensions.Logging.Abstractions e inclui métodos para logging de registros subjacentes.

public interface ILogger
{
    void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, 
Func<TState, Exception, string> formatter);
    bool IsEnabled(LogLevel logLevel);
    IDisposable BeginScope<TState>(TState state);
}

Assim, para criar um registro de log customizado, você deverá estender essa interface e implementar esses métodos.

Provedores de Logging incorporados

Existem diferentes provedores de log disponíveis, como pacotes do NuGet que podemos usar para enviar a saída do log para um meio diferente, como console, janela de depuração, EventLog, EventSource, TraceSource, etc.

A ASP.NET Core oferece suporte aos seguintes provedores:

  • 1. Console
  • 2. Debug
  • 3. EventSource
  • 4. EventLog
  • 5. TraceSource
  • 6. Azure App Services

Nota: se estiver usando a ASP.Net Core 1.x, será necessário incluir as dependências do Microsoft.Extensions.Logging em seu projeto explicitamente. Na ASP.Net Core 2.x essas dependências são incluídas por padrão.

A seguir vou mostrar a forma mais simples de usar o log do Console.

Usando o Logging do Console

Abra o Visual Studio 2017 Community no menu File e clique em New Project.

A seguir, selecione Visual C# > Web e escolha o template ASP .NET Core Web Application. Informe o nome AspnCoreLogging e clique em OK.

Escolha .NET Core e ASP .NET Core 2.1, selecione o template API e clique em OK:

Estamos criando uma Web API onde vamos ativar o Logging para o Console.

Como estamos usando a ASP .NET Core 2.1, o namespace Microsoft.Extensions.Logging.Console já está incluído no meta pacote Microsoft.AspNetCore.All.

O método CreateDefaultBuilder() no arquivo Program.cs também já inclui os provedores para console e debug. Assim não precisamos incluí-los novamente no método Configure.

Agora podemos criar os logs exibindo-os no Console através de uma instância de ILogger usando LoggerFactory e iniciando o logging.

Para isso, abra o método Configure da classe Startup e inclua o código abaixo:

Observe que injetamos uma instância de ILoggerFactory no método Configure e adicionamos a configuração para o Console.

No arquivo appsettings.json você poderá ver a configuração padrão para logging:

A seguir iniciamos o registro de log no Console exibindo uma mensagem com a hora atual que será vista no Console do Visual Studio.

Executando o projeto e verificando a janela de Console do VS 2017 teremos:

Muito bem, mas podemos também usar o ILogger em qualquer lugar da nossa aplicação. Sempre que vir o ILogger, o contêiner de injeção de dependência da ASP .NET Core vai injetar uma instância de ConsoleLogger que poderemos usar para registrar o log.

Para mostrar isso vamos injetar uma instância de ILogger em nosso controller ValuesController:

Definimos uma instância de ILogger para o controlador ValuesController no construtor e definimos para registrar logs a nível de informação nos métodos Get e Get(int id).

Assim, ao acessar http://localhost:5000/api/values ou http://localhost:5000/api/values/999 iremos ver na janela do Console do Visual Studio o log exibindo a informação:

No exemplo estamos usando o nível do Log como Information usando o método de extensão LogInformation().

Os níveis de log indicam a importância ou a gravidade das mensagens de log e os provedores de log internos incluem métodos de extensão para indicar os níveis de log.

A ASP.NET Core define os seguintes níveis de log:

Beleza, mas logar somente em modo Debug não é lá muito útil, pois precisamos logar todas as entradas da API e as exceções que porventura ocorram na aplicação e manter o registro deste log.

Na próxima parte do artigo veremos como criar um log customizado.