Monitoramento e Observabilidade - Visualizando a Saúde do Sistema

O que é Observabilidade

Observabilidade é a capacidade de entender o estado interno de um sistema a partir de suas saídas externas. Permite compreender não apenas “o que está acontecendo”, mas também “por que está acontecendo”.

Diferença do Monitoramento: O monitoramento detecta problemas conhecidos, enquanto a observabilidade permite investigar também problemas desconhecidos.

Os Três Pilares

flowchart LR
    subgraph Observability["Observabilidade"]
        Metrics["Métricas<br/>Metrics<br/>「O que está acontecendo」"]
        Logs["Logs<br/>Logs<br/>「Quais são os detalhes」"]
        Traces["Traces<br/>Traces<br/>「Como fluiu」"]
    end

Métricas (Metrics)

Registram dados numéricos em séries temporais.

Tipos de Métricas

Exemplo com Prometheus

const prometheus = require('prom-client');

// Exemplo de Counter
const requestCounter = new prometheus.Counter({
  name: 'http_requests_total',
  help: 'Total HTTP requests',
  labelNames: ['method', 'path', 'status']
});

// Exemplo de Histogram
const responseTime = new prometheus.Histogram({
  name: 'http_response_time_seconds',
  help: 'HTTP response time in seconds',
  buckets: [0.1, 0.5, 1, 2, 5]
});

// Medição
app.use((req, res, next) => {
  const end = responseTime.startTimer();
  res.on('finish', () => {
    requestCounter.inc({
      method: req.method,
      path: req.path,
      status: res.statusCode
    });
    end();
  });
  next();
});

Métricas Importantes (RED/USE)

Método RED (para serviços):
- Rate: Taxa de requisições
- Errors: Taxa de erros
- Duration: Tempo de resposta

Método USE (para recursos):
- Utilization: Utilização
- Saturation: Saturação
- Errors: Erros

Logs

Registram os detalhes dos eventos.

Logs Estruturados

// Log não estruturado (difícil de pesquisar)
console.log(`User ${userId} logged in from ${ip}`);

// Log estruturado (fácil de pesquisar e analisar)
const log = {
  timestamp: new Date().toISOString(),
  level: 'info',
  message: 'User logged in',
  userId: '123',
  ip: '192.168.1.1',
  userAgent: 'Mozilla/5.0...',
  requestId: 'req_abc123'
};
console.log(JSON.stringify(log));

Níveis de Log

Stack de Gerenciamento de Logs

ELK Stack:
Aplicação → Filebeat → Logstash → Elasticsearch → Kibana

Loki Stack:
Aplicação → Promtail → Loki → Grafana

Traces

Rastreiam o caminho que uma requisição percorre através do sistema.

Tracing Distribuído

flowchart TB
    subgraph Trace["Trace ID: abc123"]
        subgraph Gateway["Span: API Gateway (50ms)"]
            Auth["Span: Auth Service (10ms)"]
            subgraph UserSvc["Span: User Service (30ms)"]
                DB["Span: Database Query (15ms)"]
            end
        end
    end

Exemplo com OpenTelemetry

const { trace } = require('@opentelemetry/api');

const tracer = trace.getTracer('my-service');

async function processOrder(orderId) {
  return tracer.startActiveSpan('processOrder', async (span) => {
    span.setAttribute('order.id', orderId);

    try {
      await validateOrder(orderId);
      await processPayment(orderId);
      span.setStatus({ code: 1 }); // OK
    } catch (error) {
      span.setStatus({ code: 2, message: error.message }); // ERROR
      throw error;
    } finally {
      span.end();
    }
  });
}

Principais Ferramentas

Alertas

Enviam notificações baseadas em métricas.

Design de Alertas

# Exemplo do Prometheus Alertmanager
groups:
  - name: app-alerts
    rules:
      - alert: HighErrorRate
        expr: rate(http_requests_total{status=~"5.."}[5m]) > 0.1
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "High error rate detected"
          description: "Error rate is {{ $value }} for the last 5 minutes"

      - alert: SlowResponseTime
        expr: histogram_quantile(0.95, rate(http_response_time_seconds_bucket[5m])) > 2
        for: 10m
        labels:
          severity: warning

Prevenção da Fadiga de Alertas

Condições para bons alertas:
✓ Apenas eventos que requerem ação
✓ Limites apropriados (reduzir ruído)
✓ Procedimentos de resposta claros
✓ Política de escalonamento

Alertas a evitar:
✗ Apenas informativos (verificar no dashboard)
✗ Eventos que se recuperam automaticamente
✗ Alertas noturnos que não podem ser tratados

Dashboards

Estrutura do Dashboard Grafana

Resumo

A observabilidade é essencial para entender a saúde de sistemas complexos. Combinando os três pilares - métricas, logs e traces - podemos detectar problemas e investigar causas de forma fluida. Com configuração adequada de alertas e dashboards, é possível responder rapidamente a incidentes.