Observabilidade com OpenTelemetry e .Net Core

Adriano — Wed, 14 Aug 2024 19:15:18 +0000

Com o rápido avanço dos sistemas de tecnologia, e o número diverso de micro serviços necessários para atender o funcionamento de um negócio, vem se tornando cada vez mais complexo a gestão e busca por qualidade no desenvolvimento e principalmente em produção. O OpenTelemetry surgiu como uma proposta de solução capaz de facilitar e acelerar a implementação de monitoramento de aplicações modernas.

O que é o OpenTelemetry?

O OpenTelemetry é um framework de observabilidade de código aberto que permite às equipes de desenvolvimento gerar, processar e transmitir dados de telemetria em um formato unificado, provendo um conjunto de APIs, SDKs e ferramentas padronizados e independentes de fornecedor para coletar e exportar esses dados de telemetria.

Desenvolvido pela Cloud Native Computing Foundation (CNCF) com o objetivo de padronizar a coleta e roteamento de métricas, logs e traces para plataformas de monitoramento diversas.

Ao utilizar o OpenTelemetry podemos desacoplar nossos sistemas dos backends de observabilidade, pois o mesmo provê capacidade de instrumentar o código para gerar dados padronizados de telemetria e enviá-los utilizando o protocolo OTLP.

Como funciona?

Junto com as ferramentas, APIs e SDKs o OpenTelemetry disponibiliza um agente (Collector) responsável por receber os dados das suas aplicações e enviar para os backends de observabilidade.

Arquitetura do Collector

Uma das boas práticas de uso do OpenTelemetry é fazer o deploy do Collector em um servidor separado da aplicação, e configurar a aplicação para enviar dados para o endpoint do mesmo.

Componentes do Collector:

Receptores (Receivers): Responsáveis por receber dados de telemetria de várias fontes. Eles podem lidar com diferentes formatos, como OTLP (OpenTelemetry Protocol), Jaeger, Prometheus e até ferramentas comerciais ou proprietárias. Um receptor pode receber traces de solicitações HTTP, métricas de um serviço específico ou logs de aplicativos.
Exportadores (Exporters): Responsáveis por enviar os dados de telemetria processados para os backends de observabilidade, como Jaeger, Zipkin, Prometheus ou qualquer outro destino. Entre os exportadores, os baseados no OpenTelemetry Protocol (OTLP) são especialmente relevantes, pois mantêm a integridade dos dados sem perda de informações.
Processadores (Processors): Atuam na transformação e filtragem dos dados de telemetria antes de serem exportados. Permitindo aplicar regras de negócios, agregar informações, adicionar campos personalizados ou até mesmo reduzir o volume de dados. Por exemplo, um processador pode enriquecer traces com informações contextuais ou remover spans irrelevantes

Também podemos instrumentar a aplicação e enviar os dados de telemetria diretamente para os backends de observabilidade sem utilizar o collector, desta forma tornando o uso mais simples sem a necessidade de mais uma peça para gerenciar, mas em contra partida gerando forte acoplamento entre o código do sistema e o backend de observabilidade.

Projeto de exemplo

Para exemplificar melhor o funcionamento do OpenTelemetry, vamos desenvolver alguns projetos .Net Core do tipo WebApi, simulando um sistema de pedidos. Também iremos usar o Docker e Docker Compose para subir as aplicações e alguns backends de observabilidade (Prometheus, Grafana, Jaeger).

Estrutura do projeto

Criando os projetos e fazendo a instrumentação.

Os 3 projetos é do tipo WebApi versão .net core 8, após criar o projetos vamos instalar os seguintes pacotes:

Na classe Program.cs vamos fazer a instrumentação da aplicação:

Definindo url do collector e adicionamento SDK do OpenTelemetry.

var tracingOtlpGrpcEndpoint = "http://otel-collector:4317";
var otel = builder.Services.AddOpenTelemetry();

Configurando OpenTelemetry Resource e o nome da aplicação que será registrado nos dados de telemetria.

otel.ConfigureResource(resource => resource
    .AddService(serviceName: builder.Environment.ApplicationName));

Instrumentando a aplicação para enviar métricas.

otel.WithMetrics(metrics => metrics
    // Metrics provider from OpenTelemetry    
    .AddHttpClientInstrumentation()
    .AddAspNetCoreInstrumentation()
    .AddMeter("PedidoApiMetrics")

    .AddOtlpExporter(otlpOptions => 
    {
        otlpOptions.Endpoint = new Uri(tracingOtlpGrpcEndpoint);
    })
    );

Instrumentando a aplicação para enviar tracing.

otel.WithTracing(tracing =>
{
    tracing.AddAspNetCoreInstrumentation();
    tracing.AddHttpClientInstrumentation();
    tracing.AddSource("PedidoApi");
    if (tracingOtlpGrpcEndpoint != null)
    {
        tracing.AddOtlpExporter(otlpOptions =>
         {
             otlpOptions.Endpoint = new Uri(tracingOtlpGrpcEndpoint);             
         });
    }
    else
    {
        tracing.AddConsoleExporter();
    }
});

Instrumentando a aplicação para enviar logs.

otel.WithLogging(logging => 
{                    
    logging.AddOtlpExporter((otlpOptions, processorOptions) =>
    {        
        otlpOptions.Endpoint = new Uri(tracingOtlpGrpcEndpoint);                
        processorOptions.BatchExportProcessorOptions.ScheduledDelayMilliseconds = 2000;
        processorOptions.BatchExportProcessorOptions.MaxExportBatchSize = 512;
    });
});

Configurando arquivo `docker-compose.yml`

name: webapiotlp-example

networks:
  proxy:
    driver: bridge 

services:
  grafana:
    image: grafana/grafana-enterprise
    container_name: grafana
    restart: unless-stopped
    ports:
     - '3000:3000'
    networks:
      - proxy
    environment:
      - GF_AUTH_ANONYMOUS_ENABLED=true
      - GF_AUTH_ANONYMOUS_ORG_ROLE=Admin
      - GF_AUTH_DISABLE_LOGIN_FORM=true
      - GF_FEATURE_TOGGLES_ENABLE=traceqlEditor

  grafana-loki:
    image: grafana/loki:3.1.0
    container_name: grafana-loki    
    ports:
     - '3100:3100'
    volumes:
      - ./grafana-loki-config.yaml:/etc/loki/local-config.yaml
    command: 
     - -config.file=/etc/loki/local-config.yaml
     - -print-config-stderr=true
    networks:
      - proxy

  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    command: ["--config=/etc/otel-collector-config.yaml"]
    volumes:
      # - ./logs:/etc/output:rw      
      - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml
    ports:
      - 1888:1888 # pprof extension
      - 8888:8888 # Prometheus metrics exposed by the Collector
      - 8889:8889 # Prometheus exporter metrics
      - 13133:13133 # health_check extension
      # - 4317:4317 # OTLP gRPC receiver
      # - 4318:4318 # OTLP http receiver
      # - 55679:55679 # zpages extension
    networks:
      - proxy
    depends_on:
      - grafana-loki

  jaeger:
    image: jaegertracing/all-in-one:1.48.0
    restart: always
    ports:
      - "6831:6831/udp" # UDP port for Jaeger agent
      - "16686:16686" # Web UI
      # - "14268:14268" # HTTP port for spans
      # - "4317:4317" # OTLP gRPC receiver for jaeger
      # - "4318:4318" # OTLP HTTP receiver for jaeger
    environment:
      - LOG_LEVEL=debug
    networks:
      - proxy 

  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
    networks:
      - proxy

  pedido-api:
    image:  pedido-api:dev
    build: 
      context: .
      dockerfile: ./Src/00-PedidoApi/Dockerfile
    ports:
      - "8080:8080" 
    environment:
      - DELAY=2
      - BASE_ADDRESS=http://estoque-api:8080/
      - URL_POST=Estoque
    networks:
      - proxy
    depends_on:
      - otel-collector
      - jaeger

  estoque-api:
    image:  estoque-api:dev
    build: 
      context: .
      dockerfile: ./Src/01-EstoqueApi/Dockerfile
    ports:
      - "8081:8080"
    environment:
      - DELAY=1
      - BASE_ADDRESS=http://notafiscal-api:8080/
      - URL_POST=NotaFiscal
    networks:
      - proxy
    depends_on:
      - otel-collector
      - jaeger

  notafiscal-api:
    image:  notafiscal-api:dev
    build: 
      context: .
      dockerfile: ./Src/02-NotaFiscalApi/Dockerfile
    ports:
      - "8082:8080" 
    environment:
      - DELAY=0
    networks:
      - proxy 
    depends_on:
      - otel-collector
      - jaeger

Configurando receptores e exportadores no arquivo `otel-collector-config.yaml`

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: otel-collector:4317
      http:
        endpoint: otel-collector:4318

exporters:  
  debug:
    verbosity: detailed
  prometheus:
    endpoint: "0.0.0.0:8889"
    send_timestamps: true
    metric_expiration: 180m
    enable_open_metrics: true
  logging:

  otlp:
    endpoint: jaeger:4317
    tls:
      insecure: true
  otlphttp:
    endpoint: http://grafana-loki:3100/otlp

  # file:
  #   path: /etc/output/logs.json

service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [debug, logging, otlp]
    metrics:
      receivers: [otlp]
      exporters: [debug, logging, prometheus]
    logs:
      receivers: [otlp]
      exporters: [debug, logging, otlphttp]

Configurando prometheus para coletar métricas do collector no arquivo `prometheus.yml`

global:
  scrape_interval: 5s

scrape_configs:
  - job_name: 'otel-collector'
    static_configs:
      - targets: ['otel-collector:8888', 'otel-collector:8889']

Vamos capturar os logs obtidos no collector pelo grafana-loki, para funcionar local é necessário configurar no arquivo `grafana-loki-config.yaml`

auth_enabled: false

limits_config:
  allow_structured_metadata: true

server:
  http_listen_port: 3100

common:
  instance_addr: 127.0.0.1
  path_prefix: /loki
  storage:
    filesystem:
      chunks_directory: /loki/chunks
      rules_directory: /loki/rules
  replication_factor: 1
  ring:
    kvstore:
      store: inmemory

schema_config:
  configs:
    - from: 2020-10-24
      store: tsdb
      object_store: filesystem
      schema: v13
      index:
        prefix: index_
        period: 24h

ruler:
  alertmanager_url: http://localhost:9093

Executando o projeto e validando os dados coletados

Vamos criar um novo pedido fazendo uma requisição na api de pedidos usando o Postman:

Verificando no Jaeger os traces gerados:

Verificando no Prometheus as métricas geradas:

Verificando logs enviados para o grafana loki:

Quais são os benefícios ao utilizar o OpenTelemetry?

Como podemos ver, ganhamos muito ao utilizar o OpenTelemetry, com ele podemos implementar de uma forma simples e padronizada rastreabilidade de ponta a ponta em nossas aplicações, ajudando na identificação de gargalos e melhoria de desempenho. Também nos auxilia na detecção de erros, mostrando todo o fluxo de solicitações e logs. Não tenho dúvidas que é uma ferramenta essencial que irá ajudar o desenvolvedor a obter melhor qualidade em seus projetos.

acslook / WebApiOTLP-Example

Agradecimento

Obrigado por ler até aqui. Se você tiver alguma dúvida ou sugestão, não deixe de comentar.

DEV Community: Adriano