SLOs de latencia y error con Prometheus recording rules
Por qué los SLOs no son simples métricas
En la práctica de SRE, un SLO (Service Level Objective) no es una métrica cruda que se consulta de vez en cuando. Es un compromiso operativo que debe evaluarse continuamente, con ventanas de tiempo deslizantes y presupuestos de error que alerten antes de que el usuario final perciba degradación. Si calculamos el cumplimiento del SLO sobre métricas directas cada vez que hacemos una consulta, pagamos un coste computacional innecesario y, peor aún, obtenemos resultados inconsistentes entre paneles y alertas. La solución estándar en el ecosistema Prometheus es usar recording rules: reglas que precalculan consultas complejas en intervalos regulares y almacenan el resultado como series temporales nuevas. Esto no solo acelera las consultas, sino que permite modelar ventanas de evaluación largas (como 30 días) sin tener que recorrer millones de muestras en cada evaluación.
Definición del presupuesto de error
El concepto central es el presupuesto de error: el porcentaje de tiempo (o de solicitudes) que podemos permitir que fallen sin incumplir el SLO. Para un SLO de disponibilidad del 99.9% en un periodo de 30 días, el presupuesto de error es del 0.1%. En términos de solicitudes, si recibimos 10 millones de peticiones, solo podemos fallar 10,000. La clave para alertar de forma proactiva es consumir el presupuesto más rápido de lo planeado. Por ejemplo, si en una hora consumimos el 5% del presupuesto mensual, es una señal de alarma.
Para latencia, definimos un SLO como "el 95% de las solicitudes deben completarse en menos de 300 ms". El presupuesto de error aquí se traduce en el porcentaje de solicitudes que pueden exceder ese umbral. Con Prometheus, esto se calcula típicamente usando histogram_quantile sobre un histograma, o bien usando el ratio de eventos lentos contra el total. La recomendación es usar histogramas nativos de Prometheus (o los clásicos) porque permiten calcular percentiles sin almacenar cada muestra individual.
Diseño de las recording rules para latencia
Vamos a construir un ejemplo real. Supongamos que exponemos una métrica http_request_duration_seconds como histograma, con etiquetas job, route y status. Nuestro SLO es que el 95% de las peticiones en el último mes (30 días) sean menores a 300ms. La consulta directa para el percentil 95 sería:
histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le))
Pero evaluar esto sobre 30 días en cada consulta es inviable. Creamos una recording rule que calcule el percentil 95 en ventanas de 5 minutos y lo almacene como una serie nueva. En el archivo rules.yml:
groups:
- name: slo_latency.rules
interval: 1m
rules:
- record: job:slo:latency_p95:rate5m
expr: |
histogram_quantile(0.95,
sum(rate(http_request_duration_seconds_bucket[5m])) by (le, job)
)
- record: job:slo:latency_p99:rate5m
expr: |
histogram_quantile(0.99,
sum(rate(http_request_duration_seconds_bucket[5m])) by (le, job)
)
Esta regla se evalúa cada minuto, usando una ventana de 5 minutos. La serie resultante job:slo:latency_p95:rate5m ya está lista para consultarse en paneles y alertas. Sin embargo, esto solo nos da una vista de corto plazo. Para el SLO mensual, necesitamos una ventana deslizante de 30 días. Prometheus no permite directamente ventanas de 30d en rate por el coste de memoria, pero podemos aproximarlo con una regla que use sum_over_time sobre los contadores del histograma.
Presupuesto de error con recording rules
El enfoque más robusto para el presupuesto de error es calcular el ratio de eventos malos (lentos o con error) contra el total, en una ventana larga. Para ello, necesitamos dos métricas derivadas: el total de solicitudes y el total de solicitudes que incumplen el SLO. Supongamos que tenemos un histograma donde el bucket le="+Inf" cuenta todas las solicitudes, y queremos saber cuántas superaron 300ms. Podemos crear una regla que calcule el ratio de error de latencia así:
- record: job:slo:error_budget_latency:ratio_rate5m
expr: |
(
sum(rate(http_request_duration_seconds_bucket{le="0.3"}[5m])) by (job)
) / (
sum(rate(http_request_duration_seconds_bucket{le="+Inf"}[5m])) by (job)
)
Este ratio nos dice la fracción de solicitudes que cumplen el target de latencia. Para el presupuesto de error, necesitamos el complemento: 1 - ratio. La regla quedaría:
- record: job:slo:error_budget_latency:burn_rate5m
expr: |
(1 - (
sum(rate(http_request_duration_seconds_bucket{le="0.3"}[5m])) by (job)
/
sum(rate(http_request_duration_seconds_bucket{le="+Inf"}[5m])) by (job)
)) * 100
El resultado es un porcentaje de error actual. Para compararlo con el presupuesto mensual, necesitamos el error acumulado en 30 días. Esto se logra con sum_over_time sobre el ratio, pero teniendo cuidado de que el ratio no es una función lineal. La práctica recomendada es precalcular los contadores totales y los contadores de eventos lentos en ventanas de 5 minutos, y luego usar sum_over_time para acumularlos.
Reglas para error acumulado mensual
Vamos a crear dos reglas: una para el total de solicitudes en la ventana, y otra para el total de solicitudes lentas. Usamos increase para obtener el incremento en cada intervalo de 5 minutos, y luego lo acumulamos con sum_over_time sobre 30 días. El truco es que sum_over_time sobre un increase de 5m nos da el total acumulado. Definimos:
- record: job:slo:requests_total:increase5m
expr: |
sum(increase(http_request_duration_seconds_count[5m])) by (job)
- record: job:slo:requests_slow_total:increase5m
expr: |
sum(increase(http_request_duration_seconds_bucket{le="0.3"}[5m])) by (job)
Luego, para el error acumulado en 30 días, usamos una regla que consulte estas series y las acumule. Sin embargo, sum_over_time no funciona directamente sobre una serie que ya es un incremento (produciría doble contaje). La solución es usar sum_over_time sobre la serie de incrementos sin volver a aplicar increase. La regla quedaría:
- record: job:slo:error_budget_30d:ratio
expr: |
1 - (
sum_over_time(job:slo:requests_slow_total:increase5m[30d])
/
sum_over_time(job:slo:requests_total:increase5m[30d])
)
Este valor es el porcentaje de solicitudes que han sido lentas en los últimos 30 días. Si nuestro SLO permite un 5% de lentitud (es decir, el 95% debe ser rápido), entonces el presupuesto consumido es 1 - ratio. Para alertar, definimos una regla de alerta que se dispare si el ratio de error acumulado supera el 95% (es decir, si el error es mayor al 5%).
Alertas por burn rate
El enfoque de burn rate es más práctico. La burn rate es la velocidad a la que consumimos el presupuesto. Si el SLO es 99.9%, el presupuesto de error es 0.1%. Una burn rate de 1 significa que estamos consumiendo el presupuesto exactamente al ritmo planeado (el error real es 0.1%). Una burn rate de 10 significa que estamos fallando al 1%, consumiendo el presupuesto 10 veces más rápido. La alerta multi-ventana de Google SRE usa burn rates de 14.4 (para alertar en 1 hora) y de 2 (para alertar en 6 horas). Con Prometheus, podemos calcular la burn rate como el ratio entre el error real y el presupuesto objetivo.
- record: job:slo:burn_rate_latency:5m
expr: |
(
1 - (
sum(rate(http_request_duration_seconds_bucket{le="0.3"}[5m])) by (job)
/
sum(rate(http_request_duration_seconds_bucket{le="+Inf"}[5m])) by (job)
)
) / 0.05 # Para SLO de 95% (error permitido 5%)
Esta regla produce un valor que, si es mayor que 14