Como desenvolvedor de back -end que trabalha com microsserviços nos últimos anos, uma verdade se tornou dolorosamente óbvia: a depuração de problemas de produção em sistemas distribuídos pode parecer que o detetive trabalha no escuro.
Você tem serviços de chamada de serviços, às vezes dezenas de profundidade. Um usuário clica em um botão na interface do usuário e 15 microsserviços entram em ação. Se algo quebrar – ou pior, apenas diminui a velocidade – descobrindo onde e por que mastigar horas.
É exatamente por isso que a observabilidade é importante. E se você estiver construindo ou mantendo microsserviços em 2024, o OpenElemetria é a ferramenta que você deseja no seu canto.
O que é a observabilidade, realmente?
A observabilidade é mais do que apenas logs. Trata -se de entender por que seu sistema está se comportando de uma certa maneira, não apenas o que está fazendo. No centro, estamos falando de três pilares:
- Logs – eventos brutos, úteis para depuração.
- Métricas – números que você pode rastrear com o tempo (por exemplo, contagem de solicitações, CPU).
- Rastreios-a solicitação de ponta a ponta flui entre serviços (também conhecidos como sua “pilha de chamadas” distribuída).
As ferramentas de monitoramento tradicionais se concentram principalmente em métricas e toras, mas o rastreamento é o verdadeiro mudança de jogo para microsserviços.
Por que escolhemos o Opentelemetria
Experimentamos várias pilhas de observabilidade-Datadog, New Relic, Prometheus, Jaeger, Zipkin-mas todos tiveram um problema: eles eram bloqueados por fornecedores ou careciam de consistência entre os idiomas.
Opentelemetria (OTEL) verificou todas as nossas caixas:
- Faça uma fonte aberta, sob CNCF
- Trabalha em todos os idiomas (usamos o Node.js, Go e Python)
- Vendedor-neutro-Exportar para Grafana, Jaeger, Nova Relic, etc.
- Apoiado por todos na indústria (literalmente: AWS, GCP, Microsoft, etc.)
Como usamos o OpenteElemetria em Node.js Microservices
Deixe -me orientá -lo na maneira como realmente instrumentamos um serviço real. Digamos que tenhamos um serviço de usuário simples construído no Node.js usando o Express. Ele expõe um ponto de extremidade `/usuários ‘que busca dados do usuário. Abaixo estão as etapas.
Etapa 1: Instale dependências
npm install @opentelemetry/api \
@opentelemetry/sdk-node \
@opentelemetry/auto-instrumentations-node \
@opentelemetry/exporter-trace-otlp-http
Vamos exportar traços via OTLP para uma instância local de Jaeger.
Etapa 2: Crie rasting.js para inicializar o Opentelemetria
Javascript: rasting.js
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
const { Resource } = require('@opentelemetry/resources');
const traceExporter = new OTLPTraceExporter({
url: '
});
const sdk = new NodeSDK({
traceExporter,
instrumentations: [getNodeAutoInstrumentations()],
resource: new Resource({
[SemanticResourceAttributes.SERVICE_NAME]: 'user-service',})
});
sdk.start();
Etapa 3: adicione -o ao seu arquivo de entrada
JavaScript: Index.js
require('./tracing'); // Always load this first
const express = require('express');
const app = express();
app.get('/users', (req, res) => {
res.json([{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }]);
});
app.listen(3000, () => console.log("User service running on port 3000"));
Nosso serviço agora está exportando traços.
Etapa 4: gire o Jaeger localmente (ou use o tempo de Grafana)
Aqui está como testamos localmente:
docker run -d --name jaeger \
-e COLLECTOR_OTLP_ENABLED=true \
-p 4318:4318 -p 16686:16686 \
jaegertracing/all-in-one:latest
Encadear traços entre serviços
Agora diga que você tem outro serviço-serviço de ordem-que chama o serviço do usuário. Se ambos forem instrumentados com o Opengelemetria, você receberá um vestígio completo da solicitação do usuário pulando entre eles.
E a melhor parte? O Opentelemetria lida com a propagação de contexto de rastreamento via cabeçalhos HTTP automaticamente. Você não precisa passar manualmente IDs entre serviços.
Adicionando vãos personalizados para a lógica de negócios
Às vezes, a instrumentação automática não é suficiente. Por exemplo, se você deseja rastrear uma consulta de banco de dados ou chamada de API externa:
const { trace } = require('@opentelemetry/api');
const tracer = trace.getTracer('user-service');
app.get('/users', async (req, res) => {
const span = tracer.startSpan('fetch-user-data');
try {
const users = await fetchUsersFromDB();
res.json(users);
} catch (err) {
span.recordException(err);
throw err;
} finally {
span.end();
}
});
Isso é super útil quando você deseja acompanhar o desempenho de uma lógica de negócios específica.
Práticas recomendadas que aprendemos da maneira mais difícil
1. Use convenções semânticas
Em vez de inventar seus próprios nomes de atributos, siga as convenções semânticas Opentelemetria. Isso facilita o entendimento e compatível com seus traços com ferramentas como Grafana, Tempo, etc.
Exemplo:
JavaScript
span.setAttribute("http.method", req.method);
span.setAttribute("http.route", req.path);
2. Amostra sabiamente
Se você rastrear cada solicitação, seu sistema se afogará em dados. Use amostragem de rastreamento (por exemplo, 10%, ou apenas erros).
JavaScript
const sdk = new NodeSDK ({
sampler: new TraceIdRatioBasedSampler (0.1), // 10% sampling
});
3. Use o coletor de Opentelemetria na produção
Não exporte dados de telemetria diretamente de seus serviços para o seu back -end. Encaminhe -o através do coletor de Opentelemetria – ele oferece buffer, lotes, tentativas e conversão de formato.
4. Não registre pii em vãos
Este é crítico. Tenha muito cuidado para não armazenar nomes de usuário, e -mails, informações do cartão de crédito etc. nos atributos ou logs do span. Atenha -se a metadados e identificadores.
Onde isso nos ajudou mais
- Questões de latência de depuração: ver traços completos em 4-5 microsserviços nos ajudaram a identificar gargalos em minutos.
- Identificando tempestades de repetição: Vimos um serviço chamando outro em um loop com tentativas, algo que não teríamos capturado por troncos.
- Regressões de implantação: comparar traços de uma versão com a seguinte nos mostrou exatamente o que mudou.
Bônus: rastreamento em uma pilha de vários idiomas
Estamos usando o Node.js para alguns serviços, vá para outros. O OpenTelemetria facilitou o instrumento e o envio de todos os dados para um único local – Jaeger para Dev, Grafana Cloud em estadiamento/Prod.
Nenhum bloqueio de fornecedor. Nenhuma incompatibilidade em formatos de rastreamento. Apenas pura visibilidade.
Conclusão: Se você estiver construindo microsserviços, comece com a observabilidade
- Os microsserviços nos dão escala e flexibilidade, mas também trazem complexidade. Sem observabilidade adequada, você está voando cego.
- O OpenTelemetria se tornou uma parte central de nossa arquitetura, não apenas para depuração, mas para otimizar o desempenho, a confiabilidade e, finalmente, a experiência do usuário.
Se alguém ainda não o usa, recomendo fortemente dar uma chance. Mesmo uma configuração básica com Jaeger e alguns serviços fará você se perguntar como você já viveu sem ela.
