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_exportercon módulos de red, yblackbox_exporterpara 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_statusyremote_ip. - Correlación mediante etiquetas: Ambas fuentes comparten una etiqueta común:
apposervice. 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_totalynode_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:
- Métrica anómala:
node_network_transmit_drop_totalsube para el host que ejecutapayment-service. - Log correlacionado: En Loki ejecutamos:
{app="payment-service"} |= "latency_ms > 2000" | json - 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 comoclient_ipsin indexar, usando filtros|~en vez de etiquetas. - En Prometheus, evita
instancecon muchos valores; agrupa porjoboservice.
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.
comentarios(0)
$ dejar comentario