Carregando
0xA0Lição 11 de 15

Observabilidade: logs, métricas e traces

Enxergue dentro de uma frota de serviços com logs estruturados, IDs de correlação, métricas RED, traces distribuídos, health checks e SLOs.

30 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Escrever logs estruturados que carregam um ID de correlação (de trace)
  • Monitorar serviços com métricas RED e definir SLOs com error budgets
  • Ler um trace distribuído para descobrir para onde vai o tempo

Um cliente em Europa diz que o pedido dele levou 9 segundos. No monólito, você abriria um log. Agora a requisição passou pelo gateway, por Pedidos, Cardápio, Pagamentos e Cozinha - cinco serviços, talvez vinte instâncias. Sem observabilidade, você está chutando.

Os três pilares:

  • Logs - o que aconteceu, em JSON estruturado (campos pesquisáveis, não prosa), cada linha carregando o trace ID da requisição para você encontrar todas as linhas sobre uma requisição em todos os serviços.
  • Métricas - números ao longo do tempo. Para serviços movidos a requisições, acompanhe o RED: Rate (requisições por segundo), Errors (falhas por segundo), Duration (percentis de latência, como p95 e p99). Para recursos, o USE: utilização, saturação e erros.
  • Traces - o caminho de uma requisição por todos os serviços, como uma árvore de spans cronometrados. O OpenTelemetry é o padrão neutro de fornecedor para produzir os três.
a structured log line
{"time": "2026-10-02T18:30:01.204Z", "level": "warn", "service": "payments",
 "trace_id": "4bf92f3577b34da6", "span_id": "00f067aa0ba902b7",
 "message": "card declined, retrying", "order_id": 42, "attempt": 2}

O trace ID viaja com cada chamada, normalmente no cabeçalho HTTP traceparent do W3C (e nos cabeçalhos das mensagens, no caso de eventos), para que cada serviço possa marcar os próprios logs e spans com ele.

Lendo um trace

trace.py
1spans = [  # (span id, parent, service and operation, start ms, duration ms)
2    ("a", None, "gateway POST /orders", 0, 940),
3    ("b", "a", "ordering place_order", 5, 925),
4    ("c", "b", "menu get_prices", 10, 60),
5    ("d", "b", "payments charge", 75, 780),
6    ("e", "d", "fraud-check score", 80, 720),
7    ("f", "b", "kitchen create_ticket", 860, 60),
8]
9
10def show(parent, depth):
11    for span_id, span_parent, name, start, duration in spans:
12        if span_parent == parent:
13            bar = " " * (start // 40) + "#" * max(1, duration // 40)
14            label = "  " * depth + name
15            print(f"{label:<28} {duration:>4} ms |{bar}")
16            show(span_id, depth + 1)
17
18show(None, 0)
Saída
gateway POST /orders          940 ms |#######################
  ordering place_order        925 ms |#######################
    menu get_prices            60 ms |#
    payments charge           780 ms | ###################
      fraud-check score       720 ms |  ##################
    kitchen create_ticket      60 ms |                     #

O gráfico em cascata deixa óbvio: a maior parte dos 940 ms é a verificação antifraude dentro de Pagamentos. Sem tracing, cada equipe juraria que o seu serviço era rápido - e todas estariam certas.

Health checks e SLOs

  • Checagens de liveness respondem “o processo travou? reinicie-o”. Checagens de readiness respondem “ele consegue atender tráfego agora?” - um serviço aquecendo o cache ainda não está pronto. Mantenha as checagens de liveness simples: se elas dependerem do banco de dados, uma instabilidade no banco reinicia todas as instâncias.
  • Um SLO (service level objective) é uma meta de confiabilidade que importa para os usuários: “99,9% dos pedidos dão certo em 30 dias”. Os 0,1% restantes são o error budget (orçamento de erros) - gaste-o com releases arriscados e, quando ele acabar, desacelere e corrija a confiabilidade.
  • Alerte sobre sintomas que os usuários sentem (taxa de erros, latência, error budget sendo consumido rápido), não sobre cada pico de CPU.

Principais conclusões

  • Use logs estruturados com um trace ID propagado; o OpenTelemetry padroniza logs, métricas e traces.

  • Acompanhe as métricas RED - taxa, erros e percentis de duração - de cada serviço.

  • Traces distribuídos mostram para onde vai o tempo entre os serviços.

  • Separe liveness de readiness, defina SLOs com error budgets e alerte sobre sintomas.

Quiz da aula

7 perguntas · aprovação com 5 acertos · até 50 XP

Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.

Pratique: simule padrões de microsserviços com Python

Crie pequenas simulações em Python dos padrões, como roteadores, sagas, outboxes, circuit breakers e traces, e execute-as com entradas de exemplo. Elas rodam localmente no navegador; não é preciso ter servidores nem contêineres.

Exercício 1

Leia um trace

+25 XP

Cada linha da entrada é um span: id parent service start_ms duration_ms (pai - para a raiz). Imprima os spans como uma árvore indentada (dois espaços por nível, filhos na ordem de início) no formato payments 780 ms (self 60 ms), em que o tempo próprio (self time) é a duração do span menos o tempo coberto pelos filhos diretos dele (suponha que os filhos não se sobrepõem). Depois imprima total: 940 ms e slowest self time: fraud-check (720 ms).

  • Pedido lento
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Exercício 2

Confira o error budget

+25 XP

A primeira linha da entrada é o SLO em porcentagem (como 99.9). Cada linha seguinte é day requests failed para um dia do mês até agora. Imprima a disponibilidade de cada dia com 3 casas decimais (day 1: 99.950%) e depois os totais: availability: 99.912%, budget: 120 failures allowed, 106 used (88%) e um status: healthy (menos de 50% usado), caution (50 a 99%) ou FROZEN: no risky deploys (100% ou mais).

  • Meio do mês
  • Semana ruim
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Dúvidas sobre esta lição

Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.

Carregando publicações…