Adicionar observabilidade a um aplicativo nativo de nuvem

Concluído

Agora que você entende a importância da observabilidade, verá como pode incluí-la no seu aplicativo nativo de nuvem. Faça essa etapa adicionando o OpenTelemetry ao seu aplicativo.

Adicionar o OpenTelemetry ao seu aplicativo

O .NET tem um avançado ecossistema de ferramentas de observabilidade internas que produzem registros em log, métricas e dados de rastreamento. Você pode usar essas ferramentas para adicionar observabilidade ao seu aplicativo nativo de nuvem. Essas bibliotecas são:

• Registro em log: Microsoft.Extensions.Logging.ILogger
• Métricas: System.Diagnostics.Metrics.Meter
• Rastreamento: System.Diagnostics.Activity e System.Diagnostics.ActivitySource

O OpenTelemetry consome toda a telemetria anterior, mas primeiro seu aplicativo nativo de nuvem precisa adicionar suporte ao OpenTelemetry por meio de pacotes NuGet. Esses pacotes podem ser categorizados em três grupos:

Categoria	Pacote	Descrição
API principal	OpenTelemetry	A biblioteca principal que fornece a funcionalidade central do OpenTelemetry.
API principal	OpenTelemetry.Extensions.Hosting	Fornece métodos de extensão para iniciar e interromper automaticamente o rastreamento do OpenTelemetry em hosts ASP.NET Core.
Instrumentação	OpenTelemetry.Instrumentation.AspNetCore	Instrumentação para aplicativos ASP.NET Core. Esse pacote coleta um grande número de métricas sobre seu aplicativo sem que você precise escrever nenhum código.
Exportador	OpenTelemetry.Exporter.Console	O exportador para o console permite que o aplicativo grave a telemetria no console.

Muitos outros pacotes de instrumentação e exportadores estão disponíveis para serem incluídos em seu aplicativo nativo de nuvem. Para obter mais informações, confira .NET observabilidade com o OpenTelemetry. Dependendo do tipo de aplicativo que você está criando, é possível adicionar os pacotes mais relevantes para você.

Este módulo se concentra no uso do OpenTelemetry com o aplicativo nativo de nuvem eShopLite. Este aplicativo foi criado com o .NET Core e o Blazor WebAssembly, o que significa que todos os exemplos de código são baseados no aproveitamento da injeção de dependência.

Você pode optar por incluir todos os pacotes OpenTelemetry para os serviços Produtos e Store no aplicativo de microsserviços. No entanto, em um aplicativo do mundo real, você tem muito mais serviços. Adicionar todos esses pacotes a cada um deles envolve duplicação desnecessária. Uma abordagem melhor é adicionar um novo projeto de diagnóstico à sua solução, ao qual qualquer microsserviço pode fazer referenciar para ser observado.

Aqui está um exemplo de código que cria um método AddObservability que um microsserviço pode chamar para usar o OpenTelemetry:

using OpenTelemetry.Metrics;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

namespace Microsoft.Extensions.DependencyInjection;

public static class DiagnosticServiceCollectionExtensions
{
  public static IServiceCollection AddObservability(this IServiceCollection services,
      string serviceName,
      IConfiguration configuration)
  {
    // create the resource that references the service name passed in
    var resource = ResourceBuilder.CreateDefault().AddService(serviceName: serviceName, serviceVersion: "1.0");

    // add the OpenTelemetry services
    var otelBuilder = services.AddOpenTelemetry();

    otelBuilder
        // add the metrics providers
        .WithMetrics(metrics =>
        {
          metrics
            .SetResourceBuilder(resource)
            .AddRuntimeInstrumentation()
            .AddAspNetCoreInstrumentation()
            .AddHttpClientInstrumentation()
            .AddEventCountersInstrumentation(c =>
            {
              c.AddEventSources(
                      "Microsoft.AspNetCore.Hosting",
                      "Microsoft-AspNetCore-Server-Kestrel",
                      "System.Net.Http",
                      "System.Net.Sockets");
            })
            .AddMeter("Microsoft.AspNetCore.Hosting", "Microsoft.AspNetCore.Server.Kestrel")
            .AddConsoleExporter();

        })
        // add the tracing providers
        .WithTracing(tracing =>
        {
          tracing.SetResourceBuilder(resource)
                      .AddAspNetCoreInstrumentation()
                      .AddHttpClientInstrumentation()
                      .AddSqlClientInstrumentation();
        });

    return services;
  }

  // Add the Prometheus endpoints to your service, this will expose the metrics at http://service/metrics
  public static void MapObservability(this IEndpointRouteBuilder routes)
  {
    routes.MapPrometheusScrapingEndpoint();
  }
}

O método retorna uma classe IServiceCollection que pode ser adicionada como um serviço a um ASP.NET CoreWebApplicationBuilder.

Em seguida, essa ação cria uma variável var otelBuilder = services.AddOpenTelemetry() para armazenar o construtor OpenTelemetry. Em seguida, o código pode adicionar métricas e rastreamentos a otelBuilder.

Por exemplo, essa configuração adiciona instrumentação para:

• ASP.NET Core
• Runtime C#
• HttpCLient
• Servidor Web Kestrel

Essas métricas são exibidas no console. O método .AddConsoleExporter() adiciona o exportador ao construtor.

Ele também adiciona ao console rastreamento para:

• ASP.NET Core
• HttpClient
• Cliente SQL

A última linha retorna a classe IServiceCollection.

Com o projeto de diagnóstico concluído, é tão simples quanto adicionar uma referência ao projeto e uma única linha de código ao serviço. Por exemplo, para incluir o OpenTelemetry no serviço Produtos, adicione a referência de projeto em seu arquivo Product.csproj:

<ProjectReference Include="..\Diagnostics\Diagnostics.csproj" />

Em seguida, adicione a seguinte linha ao arquivo Program.cs sob sua declaração de builder:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddObservability("Products", builder.Configuration);

Vamos adicionar esse código aos serviços Produtos no aplicativo eShopLite.