SLO OpenTelemetry en Dynatrace: disponibilidad y latencia con DQL

SLO OpenTelemetry en Dynatrace: convierte tus spans en SLO de disponibilidad y latencia con DQL, controla el coste de las consultas y verifícalos.
SLO OpenTelemetry dans Dynatrace : disponibilité et latence en DQL

Tus servicios envían sus trazas por OTLP, pero tus objetivos de fiabilidad siguen siendo cifras en una página de wiki. Sin un SLO OpenTelemetry conectado a esos datos, nadie sabe si el servicio cumple su promesa, ni cuánto presupuesto de error (error budget) queda antes de congelar los pasos a producción.

El objetivo de este tutorial: crear dos objetivos de nivel de servicio (SLO) en Dynatrace a partir de spans de OpenTelemetry, uno de disponibilidad y otro de latencia, escritos en DQL, y después comprobar sus valores. El contenido se dirige a Dynatrace SaaS (Grail, aplicación Service-Level Objectives). Una sección indica la alternativa para Dynatrace Managed.

Si todavía dudas sobre qué indicadores medir, lee antes cómo elegir tus SLI: el método práctico.

Qué se mide

  • Disponibilidad: proporción de peticiones de servidor que no terminan en error. Objetivo: 99,5 % en 28 días.
  • Latencia: proporción de peticiones de servidor atendidas en menos de 500 ms. Objetivo: 95 % en 28 días.

Los dos indicadores de nivel de servicio (SLI) son ratios «eventos buenos / eventos válidos». Este formato hace legible el error budget: el 0,5 % de las peticiones puede fallar en la ventana.

Requisitos previos

  • SaaS sobre la plataforma Grail, con la aplicación Service-Level Objectives y los permisos de lectura de spans y de escritura de SLO (lista exacta en la documentación).
  • Spans de OpenTelemetry ya presentes en Grail, con el atributo service.name. Si no llega nada, sigue la checklist trazas de OpenTelemetry ausentes.
  • Spans de servidor (span.kind == "server") con un estado informado por la instrumentación.

Crear un SLO OpenTelemetry paso a paso

Paso 1: explorar los spans en un Notebook

Antes de escribir el SLI, comprueba los campos disponibles:

fetch spans, from: now() - 1h
| filter service.name == "checkout" and span.kind == "server"
| summarize total = count(),
            erreurs = countIf(span.status_code == "error"),
            p95 = percentile(duration, 95)

Líneas críticas: span.kind == "server" conserva solo las peticiones recibidas, no las llamadas salientes. span.status_code contiene el estado de OpenTelemetry. Si tus spans HTTP no pasan a error en las respuestas 5xx, filtra mejor por http.response.status_code >= 500. Los nombres exactos de los campos en Grail se describen en la documentación del Semantic Dictionary: compruébalos antes de continuar.

Paso 2: escribir el SLI de disponibilidad

La aplicación de SLO espera una serie temporal que devuelva un porcentaje. Por eso se transforman los spans en series con makeTimeseries:

fetch spans
| filter service.name == "checkout" and span.kind == "server"
| makeTimeseries {
    total = count(),
    erreurs = countIf(span.status_code == "error")
  }, interval: 1m
| fieldsAdd sli = 100 * (total[] - erreurs[]) / total[]

En la aplicación Service-Level Objectives, crea un SLO con un SLI personalizado, pega la consulta y fija el objetivo en 99,5 y la ventana en 28 días. La forma esperada (nombre del campo de resultado, ventana de consulta gestionada por la aplicación) puede cambiar: compárala con una plantilla que ofrezca la aplicación.

Paso 3: escribir el SLI de latencia

fetch spans
| filter service.name == "checkout" and span.kind == "server"
| makeTimeseries {
    total = count(),
    rapides = countIf(duration < 500ms)
  }, interval: 1m
| fieldsAdd sli = 100 * rapides[] / total[]

Se mide un ratio de peticiones rápidas en lugar de un percentil. Un percentil no se suma a lo largo de 28 días; un ratio, sí. Objetivo: 95. Crea este segundo SLO del mismo modo.

Paso 4: controlar el coste de las consultas

Un SLO reevalúa su consulta con regularidad. Consultar todos los spans de un servicio con mucho tráfico sale caro en lectura de Grail. Dos opciones más sobrias:

  • extraer una métrica a partir de los spans con OpenPipeline y escribir después el SLI con timeseries;
  • usar la métrica de OpenTelemetry http.server.request.duration (histograma) si tu SDK la exporta.

Ejemplo con una métrica extraída (el nombre debe adaptarse a tu pipeline):

timeseries {
    total = sum(otel.checkout.requests),
    erreurs = sum(otel.checkout.requests, filter: { status == "error" })
  }
| fieldsAdd sli = 100 * (total[] - erreurs[]) / total[]

Consulta métricas e histogramas con OpenPipeline para la extracción.

¿Y en Dynatrace Managed?

Managed no tiene Grail ni DQL. Los spans de OpenTelemetry ingeridos se convierten allí en peticiones de servicio: un SLO clásico puede entonces apoyarse en una expresión de métrica, por ejemplo (100)*(builtin:service.errors.server.successCount:splitBy())/(builtin:service.requestCount.server:splitBy()), filtrada por servicio. Comprueba en la documentación de tu versión que el servicio de OpenTelemetry expone realmente estas métricas.

Paso 5: leer el error budget

Con 99,5 % en 28 días y 2 millones de peticiones en la ventana, el presupuesto admite 10 000 peticiones en error. Si ya han fallado 4000 a mitad de ventana, se ha consumido el 40 % del presupuesto: el ritmo es sano. Si han fallado 8000 en una semana, el equipo frena los pasos a producción y prioriza la fiabilidad. Esta regla, escrita de antemano y aceptada por producto, evita los debates durante el incidente.

Cómo comprobar que funciona

  1. Ejecuta cada consulta de SLI en un Notebook sobre 24 horas: la curva sli debe mantenerse entre 0 y 100, sin huecos.
  2. En la aplicación de SLO se muestran el estado y el error budget restante de los dos SLO.
  3. Genera errores en un entorno de pruebas (por ejemplo, un endpoint que devuelva 500): el SLI de disponibilidad debe bajar en los minutos siguientes.

Buenas prácticas

  • Filtra por peticiones válidas: excluye los health checks y el tráfico sintético del denominador.
  • Mantén el umbral de latencia alineado con la experiencia de usuario, no con el rendimiento actual.
  • Normaliza service.name en el Collector para que el SLO sobreviva a un cambio de nombre del despliegue.
  • Añade alertas de burn rate desde la creación: consulta alertas de burn rate de SLO en Dynatrace.
  • Para desplegar estos SLO en todos tus servicios, versiónalos: consulta generar los SLO de Dynatrace con Terraform.

Preguntas frecuentes

¿Hacen falta métricas de OpenTelemetry o bastan los spans?

Los spans bastan para empezar. Para un servicio con mucho tráfico, una métrica derivada es más económica y más rápida de evaluar.

¿Por qué 28 días en lugar de un mes?

Una ventana de 28 días contiene siempre cuatro semanas completas: cada día de la semana pesa lo mismo, lo que hace comparables los SLO de un periodo a otro.

¿Qué hacer si el SLI supera 100 o queda vacío?

Un SLI vacío indica ausencia de tráfico en el intervalo (división por cero). Un SLI por encima de 100 indica un numerador mal filtrado. Vuelve al paso 1 y compara los contadores.

Conclusión

Dos consultas DQL bastan para pasar de trazas de OpenTelemetry a SLO de disponibilidad y de latencia. Empieza por un servicio crítico, valida las cifras en un Notebook y después añade las alertas de burn rate.

Siguiente paso aconsejado: presentar estos dos SLO en una revisión de equipo, con la regla de congelación de pasos a producción asociada al error budget. Un SLO compartido y comprendido por producto vale más que un SLO perfecto que solo consulta la guardia (on-call). Revisa después los umbrales tras un mes de datos reales.

span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Dynatrace es una marca de Dynatrace LLC. Las funciones de SaaS evolucionan rápido: comprueba su disponibilidad en tu entorno y en la documentación oficial.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
Traces OpenTelemetry absentes de Dynatrace : checklist de dépannage OTLP en 8 étapes

Trazas de OpenTelemetry ausentes en Dynatrace: lista de comprobación OTLP en 8 pasos

Next Post
Choisir ses SLI : la méthode pratique, des requêtes DQL aux objectifs

Elegir SLI: el método práctico, de las consultas DQL a los objetivos

Related Posts