Monitoreo y Observabilidad - Visualizando la salud del sistema

Que es la Observabilidad

La observabilidad es la capacidad de comprender el estado interno de un sistema a partir de sus salidas externas. Permite entender no solo “que esta sucediendo” sino tambien “por que esta sucediendo”.

Diferencia con el monitoreo: El monitoreo detecta problemas conocidos, pero la observabilidad permite investigar tambien problemas desconocidos.

Los Tres Pilares

flowchart LR
    subgraph Observability["Observabilidad"]
        Metrics["Metricas<br/>Metrics<br/>\"Que esta sucediendo\""]
        Logs["Logs<br/>Logs<br/>\"Cuales son los detalles\""]
        Traces["Trazas<br/>Traces<br/>\"Como fluyo\""]
    end

Metricas (Metrics)

Registran datos numericos en series temporales.

Tipos de Metricas

Ejemplo con Prometheus

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

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

// Ejemplo 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]
});

// Medicion
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();
});

Metricas Importantes (RED/USE)

Metodo RED (para servicios):
- Rate: Tasa de solicitudes
- Errors: Tasa de errores
- Duration: Tiempo de respuesta

Metodo USE (para recursos):
- Utilization: Utilizacion
- Saturation: Saturacion
- Errors: Errores

Logs

Registran detalles de eventos.

Logs Estructurados

// Log no estructurado (dificil de buscar)
console.log(`User ${userId} logged in from ${ip}`);

// Log estructurado (facil de buscar y analizar)
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));

Niveles de Log

Stack de Gestion de Logs

ELK Stack:
App → Filebeat → Logstash → Elasticsearch → Kibana

Loki Stack:
App → Promtail → Loki → Grafana

Trazas (Traces)

Rastrean la ruta que sigue una solicitud a traves del sistema.

Trazado Distribuido

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

Ejemplo con 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();
    }
  });
}

Herramientas Principales

Alertas

Envian notificaciones basadas en metricas.

Diseno de Alertas

# Ejemplo de 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

Prevencion de la Fatiga de Alertas

Condiciones para buenas alertas:
✓ Solo eventos que requieren accion
✓ Umbrales apropiados (reducir ruido)
✓ Procedimientos de respuesta claros
✓ Politica de escalamiento

Alertas a evitar:
✗ Solo informativas (verificar en dashboard)
✗ Eventos que se recuperan automaticamente
✗ Alertas nocturnas sin posibilidad de respuesta

Dashboards

Estructura de Dashboard en Grafana

Resumen

La observabilidad es esencial para comprender la salud de sistemas complejos. Al combinar los tres pilares de metricas, logs y trazas, podemos realizar de manera fluida la deteccion de problemas hasta la investigacion de causas raiz. Con una configuracion adecuada de alertas y dashboards, es posible responder rapidamente a incidentes.