MÓDULO 10 · 1 SEMANA · OBSERVABILIDADE

Observabilidade — entender sistemas que você não pode parar para inspecionar

Logs estruturados, métricas, distributed tracing, OpenTelemetry, alertas, dashboards, profiling contínuo e debugging com dados. A diferença entre monitoramento (saber que algo quebrou) e observabilidade (entender por quê).

Duração ~1 semana
Conceitos 12 fundamentais
Projeto Stack de Observabilidade
Pré-requisito Módulos 08, 09
Observabilidade Operação Confiabilidade

Doze conceitos que constroem uma visão completa de observabilidade — da teoria aos instrumentos práticos. Começa pela distinção fundamental entre monitoramento e observabilidade (Cindy Sridharan, 2018), percorre os três pilares clássicos (logs, métricas, traces) e o quarto pilar emergente (profiling contínuo), aprofunda em OpenTelemetry como padrão de instrumentação portável, e chega nos dashboards e alertas que transformam dados em ação. O módulo 08 usou SLOs como alvo de disponibilidade; este módulo fornece a instrumentação que torna SLOs mensuráveis.

01

Observabilidade vs monitoramento — a distinção de Sridharan

Monitoramento verifica estados conhecidos; observabilidade permite explorar estados desconhecidos. Os três pilares (Cindy Sridharan, "Distributed Systems Observability", 2018). O quarto pilar emergente: profiling contínuo. Cardinality como o problema central de observabilidade em escala.

estudar →
02

Logging estruturado em profundidade — além do módulo 05

Campos obrigatórios em logs de produção. Levels: quando DEBUG vira problema de performance. Correlation ID e request ID. Sampling de logs para alta cardinalidade. Log aggregation: Elasticsearch/Kibana, Loki/Grafana, CloudWatch Logs Insights. Custos reais de storage de log.

estudar →
03

Métricas e Prometheus — counters, gauges, histograms

Os quatro tipos de métrica Prometheus: counter, gauge, histogram, summary. RED method (Rate, Errors, Duration) e USE method (Utilization, Saturation, Errors). PromQL: queries para alertas e dashboards. Exemplars: ligando métricas a traces. Cardinality explosions e como evitá-las.

estudar →
04

Distributed tracing — trace ID, spans e propagação de contexto

A anatomia de um trace: trace ID, span ID, parent span, baggage. W3C Trace Context como padrão de propagação (RFC 9532). Sampling: head-based vs tail-based. Dapper (Google, 2010) como origem. Jaeger e Zipkin como backends open source. Span events e status codes.

estudar →
05

OpenTelemetry — instrumentação portável para logs, métricas e traces

A fusão de OpenCensus e OpenTracing (2019) como padrão CNCF. SDK vs API: o que o código da aplicação usa. Automatic instrumentation vs manual. OTLP como protocolo de exportação. Collector: pipeline de processamento. Instrumentação nas 3 linguagens com zero vendor lock-in.

estudar →
06

Alertas e on-call — de threshold estático a SLO-based alerting

O problema dos alertas de threshold: CPU > 80% não é alert, CPU > 80% com usuário impactado sim. SLO-based alerting e burn rate (revisitado do módulo 08 com instrumentação real). Alertmanager: routing, silencing, grouping. PagerDuty e OpsGenie. Alert fatigue: quantos alertas é demais?

estudar →
07

Dashboards e Grafana — visualização que informa decisão

Princípios de dashboard eficaz: o que eliminar, não o que adicionar. Golden signals dashboard como ponto de partida. Variáveis e templates no Grafana. Dashboard as code (Grafonnet, Grizzly). SLO dashboards com burn rate e remaining budget. A diferença entre dashboard de operação e dashboard de investigação.

estudar →
08

Log aggregation — ELK Stack, Loki e CloudWatch

Elasticsearch + Logstash + Kibana: arquitetura, indexação, Kibana Discover e KQL. Loki: log labels como métricas Prometheus — armazenamento barato, query com LogQL. CloudWatch Logs Insights para times full-AWS. Fluentd e Fluent Bit como shippers. Retenção, custo e estratégia de sampling.

estudar →
09

APM e ferramentas comerciais — Datadog, New Relic, Dynatrace

O que APM (Application Performance Monitoring) entrega além do stack open source. Datadog: agent, integrations, Watchdog. New Relic: NRQL como linguagem de query. Dynatrace: Davis AI e detecção de causa raiz automatizada. Custo real: como APM por host vira fatura surpresa em scale. Make vs buy.

estudar →
10

Profiling contínuo — Pyroscope, Parca e flame graphs em produção

A diferença entre profiling pontual (módulo 06) e profiling contínuo como quarto pilar de observabilidade. Pyroscope: flame graphs de CPU e heap ao longo do tempo. Parca: CNCF open source. Linkando traces a profiles: qual span gasta mais CPU? eBPF-based profiling sem instrumentação de código.

estudar →
11

Observabilidade em Kubernetes — kube-state-metrics, events e node exporter

Métricas de cluster vs métricas de aplicação. kube-state-metrics: pods em CrashLoopBackOff, deployments degradados. node-exporter: recursos de node. Kubernetes events como sinal de problema. Loki para logs de container. OTel Operator para auto-instrumentação de pods. Custo de observabilidade em K8s escala.

estudar →
12

Debugging orientado a dados — investigação estruturada em produção

Substituir intuição por dados na investigação de incidentes. O fluxo: alert → dashboard de golden signals → trace do request problemático → log do span afetado → métrica de saturação do recurso → profile de CPU se necessário. Exemplars como elo entre métrica e trace. RCA com dados, não com hipóteses.

estudar →
princípio orientador

Observabilidade não é sobre coletar mais dados — é sobre coletar os dados certos de forma que permita responder perguntas que você ainda não sabe que vai fazer. Monitoramento verifica que o sistema está no estado esperado; observabilidade permite explorar estados inesperados sem precisar parar o sistema, reimplantar código de debug, ou esperar que o problema se reproduza. O critério de um sistema bem instrumentado: um engenheiro que nunca viu o sistema pode investigar um incidente usando só os dados disponíveis.

Observabilidade tem custos reais: armazenamento de log, cardinality de métrica, overhead de tracing. As decisões abaixo forçam a articular onde investir e onde economizar — porque instrumentar tudo com máxima granularidade é economicamente inviável em escala.

Stack open source (Prometheus + Loki + Jaeger) ou plataforma comercial (Datadog)?

Stack open source tem custo de infra e custo de operação (alguém precisa manter Prometheus, Loki, Jaeger, Grafana, Alertmanager). Plataforma comercial tem custo por host/volume/usuário que escala rapidamente — Datadog a $23/host/mês vira $23.000/mês com 1.000 hosts. A decisão muda por tamanho: times pequenos (<10 engenheiros, <50 hosts) pagam menos com Datadog; times maiores frequentemente economizam operando o próprio stack. A exceção é quando a plataforma comercial fornece capacidade que o open source não tem (Dynatrace Davis AI, Datadog watchdog) — aí o trade-off muda.

Head-based ou tail-based sampling para tracing?

Head-based: decisão de samplear é tomada no início da requisição, antes de saber o resultado. Simples, baixo overhead. Problema: amostras aleatórias perdem requisições lentas ou com erro (que são exatamente as mais interessantes) se a taxa de erro for baixa. Tail-based: decisão é tomada após a requisição completar — amostrar 100% de erros e requisições lentas, baixa taxa de requisições normais. Mais útil, mas requer infraestrutura de tail sampling (OTel Collector com tail sampling processor). Para começar, head-based a 10-20% captura suficiente. Tail-based quando taxa de erro é baixa e você precisa de cobertura completa de casos de interesse.

Quantos logs é demais?

Logs têm custo duplo: geração (CPU e I/O) e armazenamento (ingestion em Elasticsearch custa por GB). Sem estratégia, sistemas em produção geram gigabytes por hora de logs que nunca são consultados. As práticas da indústria: DEBUG desabilitado em produção por padrão; sampling de logs de sucesso (só 1 em 100 requisições OK gera log completo, 100% das requisições com erro gera log); campos estruturados de alta cardinalidade (user_id, trace_id) apenas quando necessários. Regra prática: se um tipo de log nunca foi pesquisado em 30 dias, é candidato a remoção.

Instrumentação automática ou manual com OpenTelemetry?

Instrumentação automática (agente OTel, bytecode instrumentation em Java, auto-instrumentation em Python) captura spans de bibliotecas conhecidas (HTTP, banco, fila) sem escrever código. Cobre 80% do que você precisa com zero esforço. Instrumentação manual adiciona spans de negócio que a automação não captura: "tempo de avaliar regra de desconto", "tempo de montar resposta personalizada". A estratégia correta é automática como base, manual para os caminhos de negócio que realmente precisam de visibilidade — não instrumentar manualmente tudo, porque vira manutenção.

Alerta por anomalia ou por threshold?

Threshold estático (latência > 500ms) é simples mas gera falsos positivos em sazonalidade normal (pico de segunda-feira) e falsos negativos quando o problema está abaixo do threshold mas é anômalo para aquela hora. Alertas baseados em SLO e burn rate (módulo 08) resolvem parte disso. Alertas por anomalia (Datadog Watchdog, Google Cloud Anomaly Detection) detectam desvios do padrão histórico sem threshold fixo — mais sensíveis, mais falsos positivos em sistemas com sazonalidade alta. A combinação prática: SLO burn rate para alertas primários (baixo ruído, alta precisão), anomaly detection como sinal secundário de investigação.

O projeto instrumenta um serviço existente (o do módulo 09 ou qualquer serviço que o aluno já tenha) com a stack completa de observabilidade open source, e valida que investigação de incidente é possível usando só os dados coletados.

PROJETO PRÁTICO

Stack de Observabilidade

Instrumentar um serviço HTTP com OpenTelemetry (logs estruturados, métricas Prometheus, distributed tracing com Jaeger). Configurar Grafana com três dashboards: golden signals, SLO burn rate, e investigação de trace. Configurar dois alertas: um de fast burn e um de slow burn. Simular um incidente (latência injetada via fault injection) e documentar o passo a passo da investigação usando exclusivamente os dados coletados — do alerta até a causa raiz.

REQUISITOS
  • Instrumentação OTel completa: trace ID propagado, spans de handler e dependências, métricas RED, logs com trace_id como campo
  • Prometheus coletando métricas; Grafana dashboards de golden signals (Rate, Errors, Duration) e saturação
  • Jaeger recebendo traces via OTLP; exemplars ligando métricas Prometheus a trace IDs
  • Loki agregando logs estruturados com label de serviço e environment
  • Alert: fast burn — taxa de erro > 1% por 5 minutos
  • Alert: slow burn — SLO burn rate > 1× por 1 hora
  • Dashboard de SLO com remaining budget e trend das últimas 24h
  • Fault injection: 300ms de latência adicional em 20% das requisições por 10 minutos
  • Documento de investigação: do alerta até a causa raiz usando só dados coletados (sem "sabia que tinha bug")
  • Tudo rodando via docker-compose com config reproduzível
Observabilidade Operação Confiabilidade
STACK SUGERIDA POR LINGUAGEM
STACK
OpenTelemetry .NET SDK + OpenTelemetry.Instrumentation.AspNetCore + prometheus-net + Serilog + Loki sink + Jaeger via OTLP + Grafana + Alertmanager
ESTRUTURA / NOTAS
  • AddOpenTelemetry() em Program.cs: traces (OTLP exporter), metrics (Prometheus exporter), logs (OTLP exporter)
  • Serilog com Serilog.Sinks.Grafana.Loki para logs estruturados enviados ao Loki
  • prometheus-net.AspNetCore para /metrics endpoint
  • Exemplars habilitados no histogram para ligar P99 ao trace ID correspondente
  • docker-compose com prometheus, loki, jaeger, grafana, alertmanager
STACK
opentelemetry-sdk + opentelemetry-instrumentation-fastapi + opentelemetry-exporter-otlp + prometheus-client + python-json-logger + Loki via python-logging-loki + Grafana + Alertmanager
ESTRUTURA / NOTAS
  • FastAPIInstrumentor().instrument_app(app) para traces automáticos
  • PrometheusInstrumentator para /metrics endpoint automático via FastAPI
  • python-json-logger com campo trace_id extraído do span atual
  • LokiHandler para envio de logs ao Loki com labels service e environment
  • OTEL_EXPORTER_OTLP_ENDPOINT apontando para Jaeger via variável de ambiente
STACK
go.opentelemetry.io/otel + otelchi + otelpgx + Prometheus client_golang + slog com loki handler + Jaeger via OTLP + Grafana + Alertmanager
ESTRUTURA / NOTAS
  • otelchi.Middleware para instrumentação automática de handlers chi
  • otelpgx.NewTracer para spans automáticos de queries pgx
  • slog com handler customizado que extrai trace_id do contexto e adiciona ao JSON
  • /metrics handler servido pelo prometheus client_golang padrão
  • Exemplars em histograms usando prometheus.NewHistogramVec com exemplar support
entregável

Repositório com docker-compose reproduzível e README documentando: screenshots dos três dashboards Grafana (golden signals, SLO, trace investigator), o JSON do alerta de burn rate configurado no Alertmanager, e o documento de investigação do incidente simulado — começando pelo alerta recebido, navegando pelo dashboard de golden signals, abrindo o trace no Jaeger, correlacionando com o log do span afetado, e identificando a causa raiz (a latência injetada). O entregável real é a habilidade de investigar, não o código.

Observabilidade é pergunta obrigatória em entrevistas de sênior e SRE. O que diferencia respostas medianas de respostas fortes é a articulação do porquê de cada ferramenta — não a lista de ferramentas que se conhece.

Q.01

Explique a diferença entre os quatro tipos de métrica Prometheus (counter, gauge, histogram, summary). Para medir latência de API, qual você usaria e por quê?

Q.02

O que é cardinality em métricas e por que é um problema em escala? Dê um exemplo de label que parece inocente mas pode causar explosão de cardinality.

Q.03

Você recebe um alerta às 2h da manhã: P99 de latência do serviço de checkout subiu de 200ms para 2s. Descreva exatamente como você investigaria usando logs, métricas e traces. Qual é a sequência?

Q.04

Qual a diferença entre head-based e tail-based sampling em distributed tracing? Em que cenário tail-based é claramente superior?

Q.05

Seu time está gastando $15.000/mês com Datadog e a liderança quer cortar pela metade. Como você abordaria a redução de custo sem perder observabilidade nas partes críticas do sistema?