Observabilidade em aplicações .NET com OpenTelemetry

Q: Qual a diferença entre métricas e traces, e como elas ajudam na observabilidade?

- Métricas: São dados quantitativos que representam o estado de uma aplicação em um dado momento, como tempo de resposta, uso de CPU, e taxa de erros. Elas são úteis para monitorar a saúde e a performance geral da aplicação. - Trace: São dados que capturam o fluxo de execução dentro da aplicação, registrando o caminho das requisições e operações. Eles ajudam a identificar onde e por que ocorrem problemas, oferecendo uma visão detalhada do comportamento da aplicação.

Passo a passo para implementar observabilidade em aplicações .NET com OpenTelemetry e elevar o nível de confiança do seu serviço

Adotar práticas de observabilidade com OpenTelemetry em aplicações .NET é uma abordagem estratégica para assegurar a confiabilidade, performance e estabilidade dos serviços empresariais. A confiabilidade é essencial para qualquer serviço. Utilizando OpenTelemetry, habilitamos uma nova maneira de monitorar e analisar o comportamento das aplicações em tempo real. Além disso, podemos revolucionar a forma como detectamos e resolvemos problemas em produção. Ao reduzir o tempo de detecção (MTTD) e correção de problemas (MTTR), ajudamos as empresas a se destacarem, proporcionamos aos clientes uma experiência excepcional e reduzimos significativamente os riscos de penalidades por inatividade.

Um executivo de tecnologia enfatiza a importância de uma estratégia robusta de observabilidade para o sucesso dos negócios: “A capacidade de monitorar, analisar e otimizar o desempenho das aplicações é um diferencial competitivo. Com OpenTelemetry, conseguimos mais visibilidade, permitindo uma resposta rápida e eficaz a qualquer anomalia ou falha.” Esta perspectiva mostra como a adoção de ferramentas de observabilidade pode impactar positivamente a experiência do cliente e os resultados da empresa.

Portanto, integrar OpenTelemetry em aplicações .NET é mais do que uma tendência tecnológica; é uma maneira de manter a qualidade e a confiança no serviço.

Implementando OpenTelemetry em Aplicações .NET

Antes de iniciar a implementação de OpenTelemetry em suas aplicações .NET, é importante garantir que todos os pré-requisitos estejam atendidos. Aqui está um guia detalhado sobre as ferramentas e configurações necessárias para uma implementação bem-sucedida, além disso, você pode baixar o projeto no Github

Instalação dos Pacotes NuGet

Instale os seguintes pacotes NuGet em seu projeto .NET para habilitar a observabilidade com OpenTelemetry:

OpenTelemetry
OpenTelemetry.Instrumentation.Runtime
OpenTelemetry.Extensions.Hosting
OpenTelemetry.Instrumentation.AspNetCore
OpenTelemetry.Instrumentation.Http
OpenTelemetry.Instrumentation.Process
OpenTelemetry.Exporter.OpenTelemetryProtocol
OpenTelemetry.Exporter.Console

Para instalar esses pacotes, utilize o seguinte comando no console do Gerenciador de Pacotes NuGet:

dotnet add package OpenTelemetry

dotnet add package OpenTelemetry.Instrumentation.Runtime

dotnet add package OpenTelemetry.Extensions.Hosting

dotnet add package OpenTelemetry.Instrumentation.Http

dotnet add package OpenTelemetry.Instrumentation.Process

dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

dotnet add package OpenTelemetry.Exporter.Console

Responsabilidades e Principais Métricas de cada Pacote

OpenTelemetry

A biblioteca principal do OpenTelemetry fornece as APIs e SDKs necessários para a instrumentação e coleta de dados de observabilidade, como traces, métricas e logs. Ela serve como a base para integrar OpenTelemetry em aplicações, permitindo a criação e gestão de spans e outros dados de telemetria.

OpenTelemetry.Instrumentation.Runtime

Essa biblioteca oferece instrumentação para coletar métricas e traces relacionados ao tempo de execução do .NET. Ela captura informações sobre a performance do runtime, como uso de CPU, garbage collection e outras métricas internas, ajudando a entender melhor o comportamento da aplicação em execução.

As principais métricas coletadas pela OpenTelemetry.Instrumentation.Runtime incluem:

Uso de CPU: Mede o percentual de uso de CPU pela aplicação.
Coleta de Lixo (Garbage Collection): Contabiliza o número de coletas de lixo executadas e o tempo gasto em cada coleta.
Memória: Monitora a quantidade de memória usada pela aplicação, incluindo o tamanho do heap gerenciado e não gerenciado.
Threads: Número de threads ativas e o tempo gasto em atividades específicas.

OpenTelemetry.Extensions.Hosting

A biblioteca OpenTelemetry.Extensions.Hosting integra OpenTelemetry com o modelo de hospedagem do .NET. Ela simplifica a configuração e inicialização do OpenTelemetry dentro de aplicações .NET hospedadas, como APIs ASP.NET Core, permitindo que os desenvolvedores adicionem facilmente a instrumentação necessária.

OpenTelemetry.Instrumentation.AspNetCore

Essa biblioteca é usada para instrumentar aplicações ASP.NET Core, capturando automaticamente traces de solicitações HTTP. Ela registra a entrada e saída de requisições HTTP, incluindo detalhes como métodos, URLs, códigos de status e outros dados importantes para monitorar a performance e a saúde das aplicações web.

As principais métricas coletadas pela OpenTelemetry.Instrumentation.AspNetCore incluem:

Duração da Requisição: Tempo médio e percentil de duração das requisições HTTP.
Contagem de Requisições: Número de requisições recebidas pela aplicação.
Erros de Requisição: Contagem de respostas HTTP com códigos de erro (4xx e 5xx).
Taxa de Sucesso: Percentual de requisições bem-sucedidas.

OpenTelemetry.Instrumentation.Http

A OpenTelemetry.Instrumentation.Http é responsável por instrumentar requisições HTTP feitas por clientes HTTP dentro de uma aplicação .NET. Ela captura dados sobre todas as requisições HTTP saindo da aplicação, incluindo tempo de resposta, status e outros detalhes, facilitando o rastreamento de chamadas externas e a detecção de problemas de conectividade.

As principais métricas coletadas pela OpenTelemetry.Instrumentation.Http incluem:

Duração das Requisições HTTP: Tempo médio e percentil de duração das requisições HTTP de saída.
Contagem de Requisições HTTP: Número de requisições HTTP feitas pela aplicação.
Erros de Requisição HTTP: Contagem de respostas HTTP com códigos de erro (4xx e 5xx).
Tamanho da Resposta: Média e total do tamanho das respostas HTTP recebidas.

OpenTelemetry.Instrumentation.Process

Essa biblioteca coleta dados relacionados aos processos em execução na máquina. Isso inclui métricas como uso de CPU e memória do processo, duração do uptime e outras informações pertinentes ao ambiente de execução do processo. É útil para monitorar a saúde e a performance das aplicações no nível do sistema operacional.

As principais métricas coletadas pela OpenTelemetry.Instrumentation.Process incluem:

Uso de CPU do Processo: Percentual de uso de CPU pelo processo específico.
Uso de Memória do Processo: Quantidade de memória consumida pelo processo.
Tempo de Uptime: Tempo de atividade do processo.

OpenTelemetry.Exporter.OpenTelemetryProtocol

O OpenTelemetry.Exporter.OpenTelemetryProtocol permite que os dados coletados pela instrumentação OpenTelemetry sejam exportados usando o protocolo OpenTelemetry (OTLP). Esse protocolo é um padrão aberto para a transmissão de dados de telemetria entre sistemas, garantindo a interoperabilidade entre diferentes ferramentas de observabilidade.

OpenTelemetry.Exporter.Console

O OpenTelemetry.Exporter.Console é um exportador simples que envia os dados de telemetria coletados para o console da aplicação. Ele é útil para desenvolvimento e debugging, permitindo que os desenvolvedores visualizem facilmente os dados de traces e métricas diretamente no console durante a execução da aplicação.

Configuração Inicial no Program.cs

Após instalar os pacotes necessários, configure OpenTelemetry no arquivo Program.cs da sua aplicação. A configuração deve incluir o registro de instrumentações e exportadores.

// Adiciona instrumentação e exportadores para OpenTelemetry
builder.Services.AddOpenTelemetry().WithMetrics((options) =>
{
    options.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("Store.Cart"))
           .AddAspNetCoreInstrumentation()
           .AddHttpClientInstrumentation()
           .AddRuntimeInstrumentation()
           .AddProcessInstrumentation()
           .AddOtlpExporter(otel =>
           {
               otel.Protocol = OpenTelemetry.Exporter.OtlpExportProtocol.Grpc;
               otel.Endpoint = new Uri(builder.Configuration["OtlpExporter:Endpoint"]!);
           });
});

builder.Services.AddOpenTelemetry().WithTracing((options) =>
{
    options.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("Store.Cart"))
           .AddAspNetCoreInstrumentation()
           .AddHttpClientInstrumentation()
           .AddOtlpExporter(otel =>
           {
               otel.Protocol = OpenTelemetry.Exporter.OtlpExportProtocol.Grpc;
               otel.Endpoint = new Uri(builder.Configuration["OtlpExporter:Endpoint"]!);
           });
});

builder.Logging.ClearProviders();
builder.Logging.AddOpenTelemetry(options =>
{
    options.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("Store.Cart"))
           .AddOtlpExporter(otel =>
           {
               otel.Protocol = OpenTelemetry.Exporter.OtlpExportProtocol.Grpc;
               otel.Endpoint = new Uri(builder.Configuration["OtlpExporter:Endpoint"]!);
           });
});

// Adiciona instrumentação e exportadores para OpenTelemetry

builder.Services.AddOpenTelemetry().WithMetrics((options) =>

{

options.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("Store.Cart"))

.AddAspNetCoreInstrumentation()

.AddHttpClientInstrumentation()

.AddRuntimeInstrumentation()

.AddProcessInstrumentation()

.AddOtlpExporter(otel =>

{

otel.Protocol = OpenTelemetry.Exporter.OtlpExportProtocol.Grpc;

otel.Endpoint = new Uri(builder.Configuration["OtlpExporter:Endpoint"]!);

});

builder.Services.AddOpenTelemetry().WithTracing((options) =>

{

options.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("Store.Cart"))

.AddAspNetCoreInstrumentation()

.AddHttpClientInstrumentation()

.AddOtlpExporter(otel =>

{

otel.Protocol = OpenTelemetry.Exporter.OtlpExportProtocol.Grpc;

otel.Endpoint = new Uri(builder.Configuration["OtlpExporter:Endpoint"]!);

});

builder.Logging.ClearProviders();

builder.Logging.AddOpenTelemetry(options =>

{

options.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("Store.Cart"))

.AddOtlpExporter(otel =>

{

otel.Protocol = OpenTelemetry.Exporter.OtlpExportProtocol.Grpc;

otel.Endpoint = new Uri(builder.Configuration["OtlpExporter:Endpoint"]!);

});

O que é o `AddOtlpExporter` e como ele funciona

O método AddOtlpExporter é usado para configurar a exportação de dados de telemetria (traces, métricas e logs) para um endpoint usando o Protocolo OpenTelemetry (OTLP). Este protocolo é um padrão aberto para a transmissão de dados de observabilidade entre sistemas, permitindo a interoperabilidade entre diferentes ferramentas e plataformas de monitoramento. Abaixo está uma explicação detalhada de como o AddOtlpExporter funciona e o que ele faz.

Funções e Benefícios do `AddOtlpExporter`

Interoperabilidade: Ao usar um protocolo padrão como o OTLP, AddOtlpExporter permite que os dados de telemetria sejam enviados para uma ampla variedade de back-ends e ferramentas de monitoramento, como Prometheus, Grafana, Jaeger, e outros.
Flexibilidade: Suporta múltiplos protocolos, permitindo que os desenvolvedores escolham o melhor método de transmissão para suas necessidades específicas.
Eficácia: O uso de gRPC, por exemplo, permite uma comunicação eficiente e de baixa latência, adequada para sistemas distribuídos onde a performance é um atributo de qualidade.
Simplicidade: Facilita a configuração e a inicialização da exportação de dados de telemetria, integrando-se facilmente ao modelo de hospedagem do .NET.

Docker Compose: Passo a Passo

Vamos detalhar cada serviço configurado no arquivo docker-compose.yaml, explicando o que cada configuração faz e como ela contribui para o ambiente de observabilidade.

O arquivo docker-compose.yaml configura um ambiente completo de observabilidade com três serviços principais:

otel-collector: Coleta e exporta dados de telemetria.
prometheus: Armazena e processa métricas.
grafana: Fornece uma interface visual para monitoramento e análise dos dados coletados.
jaeger: Responsável pela interface visual e armazenamento dos traces coletados.

services:

otel-collector:
    image: otel/opentelemetry-collector-contrib
    container_name: otel-collector
    volumes:
      - ./.docker/etc/otelcol-contrib/config.yaml:/etc/otelcol-contrib/config.yaml
    command: 
      - '--config'
      - '/etc/otelcol-contrib/config.yaml'
    ports:
      - 4317:4317
      - 8889:8889
    depends_on:
      - jaeger

prometheus:
    image: prom/prometheus
    container_name: prometheus
    volumes:
      - ./.docker/etc/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - ./.docker/prometheus:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
      - '--web.enable-lifecycle'
    ports:  
      - 9090:9090
  
  grafana:
    image: grafana/grafana
    container_name: grafana
    volumes:
      - ./.docker/grafana:/var/lib/grafana    
    ports:
      - 3000:3000

jaeger:
    image: jaegertracing/all-in-one:latest
    container_name: jaeger
    ports:
      - 16686:16686
      - 14268
      - 14250

services:

otel-collector:

image: otel/opentelemetry-collector-contrib

container_name: otel-collector

volumes:

- ./.docker/etc/otelcol-contrib/config.yaml:/etc/otelcol-contrib/config.yaml

command:

- '--config'

- '/etc/otelcol-contrib/config.yaml'

ports:

- 4317:4317

- 8889:8889

depends_on:

- jaeger

prometheus:

image: prom/prometheus

container_name: prometheus

volumes:

- ./.docker/etc/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml

- ./.docker/prometheus:/prometheus

command:

- '--config.file=/etc/prometheus/prometheus.yml'

- '--storage.tsdb.path=/prometheus'

- '--web.console.libraries=/etc/prometheus/console_libraries'

- '--web.console.templates=/etc/prometheus/consoles'

- '--web.enable-lifecycle'

ports:

- 9090:9090

grafana:

image: grafana/grafana

container_name: grafana

volumes:

- ./.docker/grafana:/var/lib/grafana

ports:

- 3000:3000

jaeger:

image: jaegertracing/all-in-one:latest

container_name: jaeger

ports:

- 16686:16686

- 14268

- 14250

Arquitetura de Observabilidade com OpenTelemetry

A ilustração mostra a arquitetura de um sistema de observabilidade para uma WebAPI chamada Store.Cart, integrando várias ferramentas para coleta, processamento e visualização de dados de telemetria. A arquitetura inclui os seguintes componentes:

Store.Cart WebAPI: Esta é a aplicação principal que está sendo monitorada. Ela gera dados de telemetria, como métricas e traços, que são enviados para o OpenTelemetry Collector.
OpenTelemetry Collector: Este componente central recebe dados de telemetria da Store.Cart WebAPI. Ele processa esses dados e os exporta para outros serviços de monitoramento e análise.
- Métricas: Exportadas para o Prometheus.
- Traços: Exportados para o Jaeger.
Prometheus: Uma ferramenta de monitoramento que armazena e processa métricas recebidas do OpenTelemetry Collector. Ele coleta dados periodicamente e os mantém em seu banco de dados.
Grafana: Uma plataforma de visualização que se conecta ao Prometheus para obter dados de métricas. Grafana permite a criação de dashboards interativos para monitorar a saúde e o desempenho da Store.Cart WebAPI.
Jaeger: Um sistema de rastreamento distribuído que recebe e armazena traços do OpenTelemetry Collector. Ele permite a visualização e análise dos fluxos de execução dentro da Store.Cart WebAPI, ajudando a identificar gargalos e problemas de desempenho.

Fluxo de Dados

Store.Cart WebAPI: Envia dados de telemetria (métricas e traços) para o OpenTelemetry Collector.
OpenTelemetry Collector:
- Exporta métricas para o Prometheus.
- Exporta traços para o Jaeger.
Prometheus: Coleta e armazena métricas, disponibilizando-as para o Grafana.
Grafana: Conecta-se ao Prometheus para visualizar as métricas em dashboards.
Jaeger: Recebe e armazena traços, permitindo a análise detalhada dos fluxos de execução.

Esta arquitetura permite monitorar a aplicação Store.Cart de forma eficaz, proporcionando visibilidade completa sobre seu desempenho e comportamento, facilitando a detecção e resolução de problemas.

Conclusão

A implementação de uma arquitetura de observabilidade robusta para a aplicação em .NET utilizando o OpenTelemetry, Prometheus, Grafana e Jaeger, proporciona uma visibilidade abrangente e detalhada sobre o desempenho e a saúde do sistema. Essa configuração permite a coleta, processamento e análise de dados de telemetria, facilitando a identificação e resolução de problemas de forma proativa.

Com essa arquitetura, é possível monitorar em tempo real a performance e a estabilidade da Store.Cart WebAPI, identificar rapidamente gargalos e problemas de desempenho, e visualizar métricas importantes em dashboards interativos no Grafana. Além disso, a análise de traços no Jaeger oferece insights valiosos sobre a execução distribuída da aplicação, ajudando a melhorar a confiabilidade e a experiência do usuário final.

FAQ: Perguntas Frequentes

1. O que é OpenTelemetry e como ele pode ser utilizado em aplicações .NET?

OpenTelemetry é um conjunto de ferramentas, APIs e SDKs usado para a coleta de métricas, logs e traços distribuídos. Em aplicações .NET, ele permite instrumentar o código para coletar dados de telemetria, que podem ser exportados para ferramentas de monitoramento e análise como Prometheus e Jaeger. A utilização do OpenTelemetry melhora a visibilidade sobre a performance e a saúde da aplicação, facilitando a identificação e resolução de problemas.

2. Quais são os benefícios de integrar OpenTelemetry com Prometheus e Grafana em uma aplicação .NET?

Integrar OpenTelemetry com Prometheus e Grafana em uma aplicação .NET oferece vários benefícios:

Detecção proativa de problemas: A combinação dessas ferramentas facilita a identificação rápida de anomalias e gargalos, permitindo ações corretivas antes que afetem os usuários finais.

Monitoramento em tempo real: Prometheus coleta e armazena métricas, permitindo a análise contínua da performance da aplicação.

Visualização avançada: Grafana se conecta ao Prometheus para exibir dashboards interativos e personalizáveis, ajudando a visualizar dados de maneira eficaz.

3. Como configurar o OpenTelemetry Collector para exportar dados para Jaeger em uma aplicação .NET?

Para configurar o OpenTelemetry Collector para exportar dados para Jaeger em uma aplicação .NET, você deve definir um endpoint para o Jaeger no arquivo de configuração do OpenTelemetry Collector (config.yaml). Especifique o protocolo gRPC ou HTTP e o endpoint do Jaeger.

4. Qual a diferença entre métricas e trace, e como elas ajudam na observabilidade?

Métricas: São dados quantitativos que representam o estado de uma aplicação em um dado momento, como tempo de resposta, uso de CPU, e taxa de erros. Elas são úteis para monitorar a saúde e a performance geral da aplicação.

Trace: São dados que capturam o fluxo de execução dentro da aplicação, registrando o caminho das requisições e operações. Eles ajudam a identificar onde e por que ocorrem problemas, oferecendo uma visão detalhada do comportamento da aplicação.

5. Quais são os principais desafios na implementação de observabilidade com OpenTelemetry em aplicações .NET?

Alguns dos principais desafios na implementação de observabilidade com OpenTelemetry em aplicações .NET incluem:

Complexidade da configuração: Configurar corretamente o OpenTelemetry e integrar com outras ferramentas como Prometheus, Grafana e Jaeger pode ser complexo.
Sobrecarga de desempenho: A coleta de dados de telemetria pode adicionar uma sobrecarga à aplicação, impactando seu desempenho se não for bem gerenciada.
Manutenção e atualização: Manter a instrumentação atualizada e adaptar-se a mudanças nas APIs e SDKs do OpenTelemetry requer um esforço contínuo.
Análise e interpretação de dados: Com grandes volumes de dados coletados, a análise e interpretação corretas desses dados para extrair insights significativos podem ser desafiadoras.

Compartilhe:

Tiago Tartari

Eu ajudo e capacito pessoas e organizações a transformar problemas complexos em soluções práticas usando a tecnologia para atingir resultados extraordinários.

Qual é o desafio
que você tem hoje?

Observabilidade em aplicações .NET com OpenTelemetry

Conteúdo

Passo a passo para implementar observabilidade em aplicações .NET com OpenTelemetry e elevar o nível de confiança do seu serviço

Implementando OpenTelemetry em Aplicações .NET

Instalação dos Pacotes NuGet

Responsabilidades e Principais Métricas de cada Pacote

OpenTelemetry

OpenTelemetry.Instrumentation.Runtime

OpenTelemetry.Extensions.Hosting

OpenTelemetry.Instrumentation.AspNetCore

OpenTelemetry.Instrumentation.Http

OpenTelemetry.Instrumentation.Process

OpenTelemetry.Exporter.OpenTelemetryProtocol

OpenTelemetry.Exporter.Console

Configuração Inicial no Program.cs

O que é o AddOtlpExporter e como ele funciona

Funções e Benefícios do AddOtlpExporter

Docker Compose: Passo a Passo

Arquitetura de Observabilidade com OpenTelemetry

Fluxo de Dados

Conclusão

FAQ: Perguntas Frequentes

1. O que é OpenTelemetry e como ele pode ser utilizado em aplicações .NET?

2. Quais são os benefícios de integrar OpenTelemetry com Prometheus e Grafana em uma aplicação .NET?

3. Como configurar o OpenTelemetry Collector para exportar dados para Jaeger em uma aplicação .NET?

4. Qual a diferença entre métricas e trace, e como elas ajudam na observabilidade?

5. Quais são os principais desafios na implementação de observabilidade com OpenTelemetry em aplicações .NET?

O que é o `AddOtlpExporter` e como ele funciona

Funções e Benefícios do `AddOtlpExporter`