Admin-Sistemas ·

Correlación de métricas de red con Prometheus y Loki para detectar latencia por aplicación

Introducción: El problema de la latencia por aplicación

En entornos de producción, la latencia rara vez es un problema homogéneo. Una misma infraestructura puede servir a decenas de aplicaciones: algunas sensibles al ancho de banda, otras a la congestión de TCP, y otras a la pérdida de paquetes. Detectar que "la red va lenta" es insuficiente; necesitamos correlacionar métricas de red con logs de aplicaciones para identificar qué servicio concreto está degradado y por qué.

Este artículo técnico explica cómo unir Prometheus (métricas) y Loki (logs) para crear un dashboard de correlación que responda preguntas como: "¿Qué aplicación experimentó mayor latencia de red entre las 14:00 y las 14:05?" o "¿Este pico de retransmisiones TCP coincide con errores HTTP 503 en el microservicio X?".

Arquitectura de la solución

La arquitectura propuesta consta de tres capas:

  • Recolección de métricas de red: Usamos node_exporter con módulos de red, y blackbox_exporter para probes ICMP/TCP desde fuera del clúster.
  • Ingesta de logs: Loki recibe logs estructurados de las aplicaciones (formato JSON) que incluyen campos como app_name, latency_ms, http_status y remote_ip.
  • Correlación mediante etiquetas: Ambas fuentes comparten una etiqueta común: app o service. Esto permite consultas que cruzan métricas y logs.

Paso 1: Exponer métricas de red relevantes en Prometheus

No todas las métricas de red sirven para detectar latencia por aplicación. Las más útiles son:

  • node_network_receive_bytes_total y node_network_transmit_bytes_total: para detectar cuellos de botella de ancho de banda.
  • node_network_receive_drop_total: indicador de congestión en colas de NIC.
  • node_network_transmit_drop_total: pérdida de paquetes en salida.
  • probe_icmp_duration_seconds (de blackbox_exporter): latencia real hacia servicios externos.

Ejemplo de configuración de prometheus.yml para scrape de blackbox_exporter:

scrape_configs:
  - job_name: 'blackbox'
    metrics_path: /probe
    params:
      module: [icmp]
    static_configs:
      - targets:
        - 'api-gateway.example.com'
        - 'auth-service.example.com'
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: 192.168.1.10:9115

Esto nos da una métrica probe_icmp_duration_seconds etiquetada por instance, que podemos luego unir a logs de Loki.

Paso 2: Logs estructurados en Loki con etiquetas de aplicación

Para correlacionar, cada línea de log debe incluir el nombre de la aplicación. Un ejemplo de log JSON generado por una aplicación Python usando structlog:

{
  "timestamp": "2025-03-21T14:02:30Z",
  "app": "payment-service",
  "level": "WARN",
  "latency_ms": 2450,
  "http_status": 502,
  "route": "/api/charge",
  "client_ip": "10.0.0.55"
}

Configuramos Loki para parsear el campo app como etiqueta indexada en loki-config.yaml:

schema_config:
  configs:
    - from: 2024-01-01
      store: boltdb-shipper
      object_store: filesystem
      schema: v11
      index:
        prefix: index_
        period: 24h
      chunks:
        prefix: chunks_
        period: 24h

scrape_configs:
  - job_name: applications
    pipeline_stages:
      - json:
          expressions:
            app: app
      - labels:
          app: ""

Ahora podemos filtrar logs de Loki por aplicación con {app="payment-service"}.

Paso 3: La consulta de correlación

El corazón del artículo: una consulta que une métricas de Prometheus y logs de Loki en Grafana. Usamos el panel de "Explore" o un dashboard con dos fuentes de datos.

Consulta A (Prometheus): Obtener la latencia ICMP promedio por aplicación en los últimos 5 minutos:

avg by (instance) (probe_icmp_duration_seconds{job="blackbox"}[5m])

Consulta B (Loki): Obtener el percentil 95 de latencia desde los logs de la aplicación:

quantile_over_time(0.95, {app="payment-service"} | json | unwrap latency_ms [5m])

Pero lo más potente es combinar ambas en una sola visualización. En Grafana, creamos un panel de tipo "Table" con dos consultas, usando el campo instance de Prometheus y app de Loki como clave de unión. Ejemplo de consulta avanzada con LogQL y PromQL simultáneos (usando el plugin de Grafana para múltiples fuentes):

# PromQL
avg by (instance) (probe_icmp_duration_seconds{job="blackbox"})

# LogQL (convierto instance a app)
sum by (app) (
  quantile_over_time(0.95,
    {app=~".+"} | json | unwrap latency_ms [5m]
  )
)

Paso 4: Detección de patrones con ejemplos reales

Imaginemos que observamos un pico de latencia en el dashboard. Podemos hacer drill-down:

  1. Métrica anómala: node_network_transmit_drop_total sube para el host que ejecuta payment-service.
  2. Log correlacionado: En Loki ejecutamos:
    {app="payment-service"} |= "latency_ms > 2000" | json
  3. Causa raíz: Los logs muestran que todas las solicitudes con alta latencia van a un mismo backend externo. La pérdida de paquetes en el host coincide con ese tráfico.

Este flujo permite pasar de "la red está lenta" a "el servicio de pagos está sufriendo retransmisiones TCP hacia el gateway externo de Visa".

Paso 5: Automatización con alertas compuestas

Podemos crear alertas en Alertmanager que combinen métricas de red y logs. Ejemplo de regla que detecta latencia alta solo si también hay retransmisiones TCP:

groups:
  - name: network_latency_correlation
    rules:
      - alert: HighLatencyWithRetransmits
        expr: |
          (avg by (instance) (probe_icmp_duration_seconds) > 1.5)
          and
          (rate(node_netstat_Tcp_RetransSegments[5m]) > 10)
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Latencia alta con retransmisiones en {{ $labels.instance }}"

Consideraciones de rendimiento y cardinalidad

Al correlacionar métricas y logs, es fácil caer en alta cardinalidad si etiquetamos cada IP o cada ruta. Recomendaciones:

  • Usa etiquetas de aplicación (app) en lugar de instancias individuales cuando sea posible.
  • En Loki, indexa solo campos con baja cardinalidad (app, level, http_status). Deja campos como client_ip sin indexar, usando filtros |~ en vez de etiquetas.
  • En Prometheus, evita instance con muchos valores; agrupa por job o service.

Conclusión

La correlación de métricas de red con logs de aplicación no es trivial, pero con Prometheus y Loki (ambos parte del stack CNCF) es realizable con herramientas estándar. La clave está en un diseño de etiquetas común y en consultas que crucen ambas fuentes sin perder granularidad.

Este enfoque permite a los administradores de sistemas pasar de ser reactivos (la red va lenta) a proactivos (la aplicación X está degradada por congestión en el host Y a las Z horas). Implementa la arquitectura descrita y comenzarás a ver patrones que de otro modo quedarían ocultos en dashboards aislados.