Postmortem sin culpa con Dynatrace: plantilla de documento y consultas DQL

Postmortem sin culpa con Dynatrace: una plantilla lista para copiar, la cronología y el impacto en el error budget con DQL, y la vía Managed.
Postmortem sans blâme avec Dynatrace : modèle de document et requêtes DQL

El incidente está cerrado, la guardia (on-call) está agotada y la reunión de retrospectiva se convierte en una búsqueda de culpables. Un postmortem sin culpa cambia la pregunta: ya no es «¿quién cometió el error?», sino «¿qué hay en el sistema que hizo posible el error y lenta su detección?». Este tutorial ofrece una plantilla de documento y las consultas DQL para rellenarla con hechos extraídos de Dynatrace.

Objetivo: al terminar tendrás una plantilla de postmortem lista para copiar, una cronología reconstruida a partir de los problemas de Davis, las métricas, los logs y los spans, y una medida del impacto sobre el error budget (presupuesto de error). Las consultas DQL se aplican a Dynatrace SaaS (Grail, Notebooks). En Dynatrace Managed la plantilla sigue siendo válida; los hechos se recopilan con la interfaz de problemas, el explorador de datos y la API v2, como se indica más abajo.

Para repasar cómo agrupa Davis los eventos en problemas, consulta el módulo de Davis y problemas de la ruta de aprendizaje de SaaS.

El problema: postmortems hechos de recuerdos

Sin datos, la cronología se reconstruye de memoria, en un hilo de conversación. Las horas son aproximadas, la detección parece más rápida de lo que fue y la discusión deriva hacia las personas. Un postmortem basado en consultas reproducibles es verificable, comparable de un incidente a otro y orienta las acciones hacia el sistema. El capítulo «Postmortem Culture» del libro SRE de Google expone los principios; este tutorial los equipa con herramientas.

Requisitos previos

  • Un entorno Dynatrace SaaS con acceso a Notebooks y lectura de problemas, logs, spans y métricas en Grail.
  • El identificador del problema de Davis vinculado al incidente (formato P-XXXXXX).
  • Un SLO existente sobre el servicio afectado, idealmente con alertas de burn rate de SLO.
  • Un espacio compartido para el documento (wiki, repositorio Git, Notebook compartido).

La plantilla de postmortem sin culpa

Copia este esqueleto al comienzo de cada retrospectiva. Cada sección remite a una consulta del tutorial.

# Postmortem — <título corto, sin nombre de persona>
Estado: borrador | revisado | cerrado
Problema de Davis: P-XXXXXX   Severidad: ...

## Resumen (3 líneas)
## Impacto
- Usuarios afectados, duración, error budget consumido (consulta 3)
## Cronología (UTC)
- Inicio de la degradación / detección / alerta / atenuación / resolución (consultas 1 y 2)
## Factores contribuyentes
- Técnicos, organizativos, de detección — nunca solo «error humano»
## Qué funcionó bien
## Acciones
| Acción | Tipo (prevenir/detectar/atenuar) | Responsable | Fecha límite |

La regla de redacción: describir acciones y decisiones con el contexto disponible en ese momento. «El despliegue se lanzó porque el control de preproducción estaba en verde» en lugar de «Paul desplegó sin comprobar».

Paso 1: reconstruir la cronología del problema

Los problemas de Davis se pueden consultar en Grail. Esta consulta devuelve las marcas de tiempo y las entidades afectadas:

fetch dt.davis.problems
| filter display_id == "P-XXXXXX"
| fields event.start, event.end, event.status, event.name,
         root_cause_entity_id, affected_entity_ids
| sort event.start asc

Pueden aparecer varias filas para un mismo problema, porque su estado se actualiza con el tiempo: quédate con la más reciente para event.end. Los nombres de los campos pueden cambiar; si falta alguno, quita la línea fields para ver el registro completo.

Paso 2: situar el inicio real de la degradación

El problema se abre cuando Davis detecta una anomalía, a menudo después del inicio real. Retrocede en el tiempo con las métricas del servicio:

timeseries {
    total    = sum(dt.service.request.count),
    failures = sum(dt.service.request.failure_count)
  },
  from: "2026-09-30T13:00:00Z", to: "2026-09-30T17:00:00Z",
  interval: 1m,
  filter: { in(dt.entity.service, "SERVICE-0123456789ABCDEF") }
| fieldsAdd taux_erreur = 100 * failures[] / total[]

El primer intervalo en el que taux_erreur se aleja de su línea base marca el «inicio de la degradación». La diferencia entre ese momento y la apertura del problema es tu tiempo de detección, una de las palancas principales del MTTR. Completa con los logs de error de la misma ventana:

fetch logs, from: "2026-09-30T13:00:00Z", to: "2026-09-30T17:00:00Z"
| filter loglevel == "ERROR"
| filter dt.entity.service == "SERVICE-0123456789ABCDEF"
| summarize erreurs = count(), by: { bin(timestamp, 1m), content }
| sort erreurs desc
| limit 20

Para agrupar mensajes parecidos en lugar de contenidos idénticos, consulta el análisis de patrones de logs.

Paso 3: cifrar el impacto sobre el error budget

Cuenta las peticiones fallidas durante el incidente y compáralas con el presupuesto de la ventana del SLO:

timeseries {
    total    = sum(dt.service.request.count),
    failures = sum(dt.service.request.failure_count)
  },
  from: "2026-09-30T13:42:00Z", to: "2026-09-30T15:10:00Z",
  filter: { in(dt.entity.service, "SERVICE-0123456789ABCDEF") }
| fieldsAdd t = arraySum(total), f = arraySum(failures)
| fields t, f

Ejemplo de cálculo: un SLO del 99,9 % a 30 días y 50 millones de peticiones en la ventana dan un presupuesto de 50 000 fallos. Si f vale 12 000, el incidente ha consumido el 24 % del presupuesto. Esta cifra, más elocuente que una duración, alimenta la decisión de congelar o no las releases: consulta presupuesto de error y release gate.

Paso 4: recuperar las trazas representativas

Una o dos trazas fallidas hacen el postmortem más concreto para los desarrolladores:

fetch spans, from: "2026-09-30T13:42:00Z", to: "2026-09-30T15:10:00Z"
| filter dt.entity.service == "SERVICE-0123456789ABCDEF"
| filter request.is_failed == true
| fields start_time, trace.id, span.name, duration
| sort duration desc
| limit 5

Pega los trace.id en el documento: cada persona podrá abrir la traza distribuida y comprobar el razonamiento.

¿Y en Dynatrace Managed?

Sin Grail, obtén la cronología del problema con la API v2:

curl -s "https://VOTRE-CLUSTER/e/ID-ENV/api/v2/problems?problemSelector=displayId(\"P-XXXXXX\")" \
  -H "Authorization: Api-Token $DT_TOKEN" \
| jq '.problems[] | {displayId, title, startTime, endTime, rootCauseEntity}'

El token necesita el scope de lectura de problemas (problems.read). Las curvas de errores salen del explorador de datos y los logs, del visor de logs. La plantilla de documento, en cambio, no cambia.

Cómo comprobar que funciona

  1. Cada marca de tiempo de la cronología está vinculada a una consulta reproducible, no a un recuerdo.
  2. Dos personas que vuelvan a ejecutar las consultas obtienen las mismas cifras de impacto.
  3. El documento no contiene ningún nombre de persona en las secciones «Factores contribuyentes» y «Acciones», solo roles y sistemas.
  4. Cada acción tiene un responsable y una fecha límite, y se planifica un seguimiento en la revisión siguiente.

Buenas prácticas

  • Guardar las consultas en un Notebook dedicado al incidente y vincularlo al documento.
  • Clasificar las acciones en prevenir, detectar y atenuar: un postmortem sin acción de detección suele estar incompleto.
  • Escribir rápido: un borrador en las primeras 48 horas, cuando los datos y el contexto están frescos.
  • Compartir ampliamente: un postmortem leído por otros equipos evita la misma caída en otro lugar.
  • Medir la tendencia: sigue el tiempo de detección de un incidente a otro; es el indicador de que tus acciones funcionan.

Preguntas frecuentes

¿Un postmortem sin culpa significa que no hay responsabilidad?

No. Las acciones tienen responsables y fechas límite. Lo que desaparece es la sanción a una persona por una decisión razonable con la información de la que disponía.

¿Hace falta un postmortem para cada problema de Davis?

No. Resérvalo para los incidentes que consumen una parte notable del error budget o afectan a los clientes. Fija el umbral de antemano, por ejemplo el 10 % del presupuesto.

¿Se puede automatizar la recopilación de datos?

Sí, en parte: un Workflow activado al cerrarse un problema puede ejecutar las consultas y rellenar un borrador. Comprueba los disparadores y las acciones disponibles en la documentación de tu entorno SaaS.

Conclusión

Un postmortem sin culpa se apoya en dos pilares: un tono orientado al sistema y hechos verificables. Las consultas DQL de este tutorial convierten la cronología, el impacto y las trazas en datos reproducibles, y el error budget ofrece una medida común para decidir las prioridades.

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. Comprueba siempre los valores (puertos, versiones, tamaños) en la documentación oficial correspondiente a tu versión.

Total
0
Shares
Leave a Reply

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

Previous Post
SLO parcours utilisateur : mesurer ce que vit le client avec RUM et synthétique

SLO de recorrido de usuario: mide lo que vive el cliente con RUM y sintético

Next Post
SLO Dynatrace Managed : configuration, limites et API (tutoriel)

SLO Dynatrace Managed: configuración, límites y API (tutorial)

Related Posts