DEV Community: Bruno Santos

Automatizando geração de logs com Delegating Handler em .NET

Bruno Santos — Fri, 11 Aug 2023 13:09:25 +0000

Neste artigo vamos entender como funciona um Deleganting Handler e como podemos utilizá-lo para interceptar requisições e respostas Http e deixar de forma transparente o processo de geração de logs.

Delegating Handler

Um Delegating Handler funciona de forma similar a um filtro, onde através dele é possível interceptar requisições e respostas Http e então implementar uma lógica personalizada. Também é possível encadear vários Delegating Handlers criando uma pipeline que irá executar as lógicas personalizadas antes de serem enviadas ou recebidas pelo cliente ou servidor.

Automatizando Logs

Como foi visto, um Delegating Handler pode ser utilizado em diversos cenários no nosso dia a dia, efetuando a interceptação de requisições e respostas Http.

Abaixo iremos demonstrar como podemos fazer isso de forma rápida e fácil.

O primeiro passo é efetuar a criação de uma classe que herde de DelegatingHandler. Iremos utilizar o ILogger para efetuar a geração dos nossos logs.

public class LogDelegatingHandler : DelegatingHandler
{
    private readonly ILogger<LogDelegatingHandler> _logger;

    public LogDelegatingHandler(ILogger<LogDelegatingHandler> logger)
    {
        _logger = logger;
    }

    public LogDelegatingHandler(HttpMessageHandler innerHandler, ILogger<LogDelegatingHandler> logger) : base(innerHandler)
   {
        _logger = logger;
   }    
}

O próximo passo é efetuar o override do método SendAsyncpara que possamos interceptar o request e o response e implementar a nossa lógica personalizada.

protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
    string requestBody = null;
    string responseBody = null;

    if (request.Content != null) 
    {
        requestBody = await request.Content.ReadAsStringAsync();
    }

    _logger.LogDebug("Http request body is {requestBody}.", requestBody);

    var response = await base.SendAsync(request, cancellationToken);

    if (response.Content != null)
    {
        responseBody = await response.Content.ReadAsStringAsync();
    }

    _logger.LogDebug("Http response body is {responseBody}.", responseBody);

    return response;
}

Para que o nosso Delegating Handler possa ser facilmente utilizado, devemos então efetuar o seu registro e referenciar o seu uso nos serviços que necessitem da geração desses logs.

   static IHostBuilder CreateHostBuilder(string[] args) =>
     Host.CreateDefaultBuilder(args)
       .ConfigureAppConfiguration(app =>
       {
           app.AddJsonFile("appsettings.json");
           app.AddEnvironmentVariables();
       })
       .ConfigureServices((_, services) =>
       {
           services
               .AddTransient<LogDelegatingHandler>();

           services
               .AddTransient<ICepService, CepService>()
               .AddHttpClient("cepService")
               .AddHttpMessageHandler<LogDelegatingHandler>();
       })
       .UseSerilog((builder, configuration) =>
       {
           configuration.ReadFrom.Configuration(builder.Configuration);
       });

Com isso toda requisição Http que for feita no serviço informado será interceptada por nosso LogDelegatingHandler e terá os logs gerados.

Conclusão

O exemplo acima é apenas uma demonstração do que podemos fazer com o Delegating Handler. O objetivo foi apenas exemplificar o seu uso tornando a geração de logs mais transparente. Melhorias como a possibilidade de definição do nível de log podem ser implementadas.

Espero que tenham gostado do artigo, qualquer feedback é bem vindo.

Em breve voltarei com um outro exemplo de como podemos criar um Delegating Handler para automatizar o fluxo de autenticações.

Este exemplo está disponibilizado no GitHub:

Logs Automáticos com Delegating Handler

Referências

Delegating Handler | Microsoft Learn

TTL em documentos com MongoDB

Bruno Santos — Fri, 11 Aug 2023 12:40:15 +0000

O objetivo deste artigo é a demonstração de como podemos inserir documentos com tempo de vida (TTL — Time to Live ) no MongoDB.

Em alguns cenários a criação de documentos com tempo de vida pode ser necessário, como por exemplo, registros de logs ou de eventos. Em alguns bancos para efetuar a limpeza desses documentos seria necessário a criação de uma rotina para efetuar a exclusão desses dados após um determinado tempo. No MongoDB podemos utilizar os índices TTL para efetuar a exclusão automática desses dados.

Índices

Os índices são uma das ferramentas de otimização mais conhecidas e utilizadas para otimização de acesso, através dele o número de documentos a serem inspecionados passa a ser menor.

Para uma consulta mais detalhada sobre índices e seus tipos no MongoDB, podemos utilizar sua documentação disponível em Índices - MongoDB.

Índices TTL

De acordo com a documentação do MongoDB, índices TTL são índices especiais de campo único que são usados para remover automaticamente documentos de uma coleção após uma determinada quantidade de tempo ou em um horário de relógio específico.

Criando um índice TTL

Para efetuar a criação de um índice TTL no MongoDB vamos utilizar como modelo a estrutura abaixo.

public class EventLog
{
    public string Name { get; set; }
    public string Description { get; set; }
    public string UserName { get; set;}
    public DateTime Date { get; set; }
    public DateTime Expiration { get; set; }
}

A partir do modelo acima, ao inserir um documento no Mongo vamos utilizar o campo **Expiration **como chave a ser utilizada para a exclusão automática.

O script abaixo é responsável pela criação do índice TTL na coleção eventLog.

db.eventlog
  .createIndex( { "Expiration": 1 }, { expireAfterSeconds: 30} )

Abaixo temos o documento que será persistido no nosso banco.

{
    "Name" : "Event Log 123",
    "Description" : "Description event log",
    "UserName" : "BH",
    "Date" : ISODate("2023-04-26T19:00:00.00+0000"),
    "Expiration" : ISODate("2023-04-26T20:00:00.00+0000"),
}

Comportamento

A expiração do documento ocorrerá após o número específico de segundos ter passado desde o valor do campo indexado, no nosso caso o valor do campo **Expiration + valor de expireAfterSeconds **utilizado na criação do index.

Para o exemplo de índice e registro que criamos, a expiração do registro iria ocorrer após as “2023–04–26T20:00:30.00+0000”.

Informações adicionais

Podemos criar um índice com o campo **expireAfterSeconds **igual a 0, com isso o documento terá sua expiração logo após o horário atual ser igual ao campo do documento utilizado como referência.

Se o campo for uma matriz que contenha mais valores do tipo data, será utilizado o menor valor como parâmetro para calcular o limite de expiração.

Se o campo do documento não for uma data ou uma matriz que contenha um ou mais valores do tipo data, o documento não será excluído.

Referências

Indexes - MongoDB Manual
Índices TTL - MongoDB

C# — Operadores implícitos e explícitos

Bruno Santos — Fri, 11 Aug 2023 00:27:08 +0000

Neste conteúdo, vamos falar sobre operadores implícitos e explícitos em C# e como podemos criar os nossos próprios operadores.

Operadores explícitos

A conversão explícita ocorre quando a conversão de um tipo de dado em outro não é possível de forma direta, sendo então necessário especificar a conversão de maneira explícita no código (cast). Esse tipo de conversão pode resultar na perda de informações ou dados truncados.

double x = 1.77;
int y = (int)x;

No exemplo acima, não é possível realizar a conversão de forma natural do tipo doublepara int, sendo necessário realizar o cast. No exemplo acima teremos perda de dados ao converter o tipo double **para **int.

Operadores implícitos

São aqueles onde o compilador possui a capacidade de converter um determinado tipo de dado em outro sem a necessidade de uma conversão explícita (cast). Na conversão implícita não há perda de dados.

int x = 2023;
double y = x;

No exemplo acima foi possível realizar a conversão de x, do tipo **int **para **double **de forma natural. Vale lembrar que números reais suportam números inteiros.

Sobrecarga de operadores

O C# permite a criação de operadores explícitos e implícitos, porém não é possível redefinir um operador já existente.

public static explicit operator ObjetoDestino(ObjetoOrigem origem)
{
     // lógica de conversão
}

public static implicit operator ObjetoDestino(ObjetoOrigem origem)
{
     // lógica de conversão
}

Definindo um operador explícito

Vamos utilizar como exemplo a conversão entre as unidades grama e quilograma. Abaixo temos a definição das classes e a criação do nosso operador explícito na classe Grama que possui a lógica de conversão para Quilograma.

public class Grama
{
    public int Peso { get; set; }

    public Grama(int peso)
    {
        Peso = peso;
    }

    public static explicit operator Quilograma(Grama grama)
    {
        int peso = grama.Peso / 1000;
        return new Quilograma(peso);
    }
}

public class Quilograma
{
    public int Peso { get; set; }

    public Quilograma(int peso)
    {
        Peso = peso;
    }
}

// Como usar

Grama pesoEmGrama = new Grama(2500);
Quilograma pesoEmQuilograma = (Quilograma)pesoEmGrama;

Definindo um operador implícito

Operadores de conversões implícitas podem ser utilizados, por exemplo, em cenários de conversões de DTOs ou ViewModels para classes do nosso domínio sem a utilização de ferramentas externas como por exemplo o AutoMapper. Abaixo um exemplo de conversão implícita entre nosso DTO e nossa classe de domínio.

public class PessoaDto
{
    public string Nome { get; set; }
    public int Idade { get; set; }
    public string Email { get; set; }

    public static implicit operator Pessoa(PessoaDto pessoa)
    {
        return new Pessoa(pessoa.Nome, pessoa.Idade, pessoa.Email);
    }    
}

public class Pessoa
{
    public Guid Id { get; set; }
    public string Nome { get; set; }
    public int Idade { get; set; }
    public string Email { get; set; }

    public Pessoa(string nome, int idade, string email)
    {
        Id = Guid.NewGuid();
        Nome = nome;
        Idade = idade;
        Email = email;
    }
}

// Como usar

PessoaDto pessoaDto = new PessoaDto()
{
    Email = "contato@medium.com",
    Idade = 25,
    Nome = "Fulano"
};

Pessoa pessoa = pessoaDto;

No exemplo acima podemos efetuar a conversão do nosso DTO em nossa classe de domínio de forma natural.

Conclusão

A sobrecarga de operadores implícitos e explícitos é um recurso poderoso que pode tornar nossos códigos mais expressivos e fáceis de usar, porém nada está escrito em pedra e nenhuma solução é ideal para todos os projetos. Devemos sempre analisar o cenário, como o time trabalha, além de levantar os impactos que podem surgir em sua adoção.

Fontes

Operadores de conversão explícitos e implícitos definidos pelo usuário