Ejemplos de consultas DQL: 15 consultas listas para copiar con DQL summarize, filter y timeseries

Ejemplos de consultas DQL para la guardia: 15 consultas listas para copiar sobre logs, spans, hosts, problemas y MTTR, con consejos para adaptarlas.
Requêtes DQL exemples : 15 requêtes prêtes à copier avec DQL summarize, filter et timeseries

A las tres de la madrugada, nadie tiene ganas de escribir una consulta desde cero. Estos ejemplos de consultas DQL cubren las preguntas que se hace la guardia (on-call) cada semana: qué servicios fallan, qué hosts se saturan, qué problemas siguen abiertos, cuánto tardamos en cerrarlos. La mayoría se apoya en DQL summarize, que agrupa los registros que comparten los mismos valores y los agrega: recuento, media, percentil por servicio o por host.

Tener estas consultas preparadas en un Notebook reduce el tiempo de diagnóstico, y por tanto el MTTR, y elimina parte del toil: ya no se reinventa la misma consulta en cada incidente. También sirven de base para los indicadores SLI de un SLO.

Objetivo: quedarte con 15 consultas que se pueden probar, clasificadas por uso, y saber adaptarlas. Alcance: DQL consulta Grail, así que estas consultas valen solo para Dynatrace SaaS. Dynatrace Managed no tiene Grail; sus equivalentes pasan por el Data Explorer, los metric selectors y la API v2, que se mencionan al final del artículo.

Requisitos previos

  • Un entorno Dynatrace SaaS con Grail y acceso a los Notebooks o a los Dashboards.
  • Permisos de lectura sobre las tablas afectadas (logs, spans, eventos, métricas); dependen de tu política de IAM.
  • Datos realmente ingeridos: OneAgent, Collector de OpenTelemetry o ambos.
  • Las bases del lenguaje: si fetch, filter y summarize no te dicen nada, empieza por los fundamentos de DQL.

Una advertencia importante: los nombres de los campos dependen de la fuente. Un log enviado por OneAgent y un log recibido por OTLP no siempre tienen los mismos atributos. Antes de copiar una consulta, ejecuta fetch logs | limit 5 (o spans) y comprueba que los campos que usas existen en tu entorno.

Ejemplos de consultas DQL para logs

1. Top de fuentes de errores en la última hora

fetch logs, from:now()-1h
| filter loglevel == "ERROR"
| summarize errors = count(), by:{host.name}
| sort errors desc
| limit 10

Un registro sin host.name no se descarta: summarize lo coloca en un grupo null aparte, que conviene revisar antes de leer el top 10. Sustituye host.name por k8s.namespace.name o service.name según lo que lleven tus logs.

2. Curva de errores en 24 horas

fetch logs, from:now()-24h
| filter loglevel == "ERROR"
| makeTimeseries errors = count(), interval:15m

makeTimeseries transforma registros en una serie temporal, que se puede mostrar directamente como gráfico. Un escalón nítido en la curva suele datar un despliegue.

3. Buscar un mensaje concreto

fetch logs, from:now()-2h
| filter contains(content, "timeout")
| fields timestamp, host.name, loglevel, content
| sort timestamp desc
| limit 50

4. Extraer un código de estado del texto

fetch logs, from:now()-1h
| filter contains(content, "status=")
| parse content, "LD 'status=' INT:status"
| summarize hits = count(), by:{status}
| sort hits desc

El comando parse usa el Dynatrace Pattern Language: LD consume el texto hasta el literal e INT:status captura el entero en un campo nuevo. Para industrializar este tipo de extracción, consulta el análisis de patrones de logs.

5. Volumen de logs por fuente

fetch logs, from:now()-24h
| summarize records = count(), by:{log.source}
| sort records desc
| limit 20

Útil para detectar una fuente charlatana antes de que pese en la factura de ingesta.

DQL summarize: ejemplos para trazas y servicios

6. Latencia p95 por servicio

fetch spans, from:now()-1h
| filter request.is_root_span == true
| summarize p95 = percentile(duration, 95), calls = count(), by:{dt.entity.service}
| fieldsAdd service = entityName(dt.entity.service)
| sort p95 desc

El filtro sobre request.is_root_span conserva solo el span de entrada de cada petición en un servicio: se mide lo que percibe el llamante, no cada llamada interna.

7. Tasa de errores por servicio

fetch spans, from:now()-1h
| filter request.is_root_span == true
| summarize total = count(),
            failed = countIf(request.is_failed == true),
            by:{dt.entity.service}
| fieldsAdd error_rate = 100.0 * failed / total
| fieldsAdd service = entityName(dt.entity.service)
| sort error_rate desc

Es la forma de un SLI de disponibilidad. Para convertirlo en un SLO, consulta elegir tus SLI con DQL.

8. Encontrar una traza a partir de su identificador

fetch spans, from:now()-24h
| filter toString(trace.id) == "4bf92f3577b34da6a3ce929d0e0e4736"
| fields start_time, span.name, duration, dt.entity.service
| sort start_time asc

Práctico cuando un identificador de traza aparece en un log o en un ticket.

9. Endpoints más lentos

fetch spans, from:now()-1h
| filter request.is_root_span == true
| summarize p90 = percentile(duration, 90), calls = count(), by:{span.name}
| filter calls > 100
| sort p90 desc
| limit 15

El filtro sobre calls descarta los endpoints poco frecuentes, cuyo percentil no tiene sentido estadístico.

Infraestructura

10. Hosts por encima del 80 % de CPU

timeseries cpu = avg(dt.host.cpu.usage), by:{dt.entity.host}, from:now()-2h
| fieldsAdd host = entityName(dt.entity.host)
| filter arrayAvg(cpu) > 80

timeseries lee las métricas; arrayAvg calcula la media de la serie en el periodo para poder filtrar.

11. Memoria de los hosts

timeseries mem = avg(dt.host.memory.usage), by:{dt.entity.host}, from:now()-6h
| fieldsAdd host = entityName(dt.entity.host), peak = arrayMax(mem)
| sort peak desc
| limit 10

12. Reinicios de contenedores de Kubernetes

timeseries restarts = sum(dt.kubernetes.container.restarts),
           by:{k8s.namespace.name, k8s.pod.name}, from:now()-24h
| fieldsAdd total = arraySum(restarts)
| filter total > 0
| sort total desc

El nombre de la métrica depende de la versión de tu integración con Kubernetes: compruébalo en el navegador de métricas o en docs.dynatrace.com antes de usarlo.

Problemas y eventos

13. Problemas abiertos ahora

fetch dt.davis.problems
| filter event.status == "ACTIVE"
| fields display_id, event.name, event.category, event.start
| sort event.start desc

14. MTTR de la semana

fetch dt.davis.problems, from:now()-7d
| filter event.status == "CLOSED"
| fieldsAdd minutes = toLong(event.end - event.start) / 60000000000
| summarize problems = count(), mttr_min = avg(minutes), p90_min = percentile(minutes, 90)

La diferencia entre dos marcas de tiempo da una duración, convertida aquí a nanosegundos con toLong y después a minutos. El p90 dice más que la media: unos pocos incidentes largos bastan para falsearla. Esta consulta alimenta directamente una revisión de incidente; consulta el postmortem sin culpas con DQL.

15. Problemas por categoría en 30 días

fetch dt.davis.problems, from:now()-30d
| summarize problems = count(), by:{event.category}
| sort problems desc

Una categoría que crece de mes en mes señala una deuda de fiabilidad. Si el volumen proviene sobre todo del ruido, lee reducir el ruido de las alertas de Davis.

Cómo comprobar que funciona

  1. Abre un Notebook, pega una consulta y ejecútala. Una tabla vacía no es un error: amplía primero la ventana (from:now()-7d).
  2. Si el editor señala un campo desconocido, ejecuta fetch logs | limit 5 o fetch spans | limit 5 y compara los nombres reales.
  3. Compara una cifra con una pantalla conocida: el número de problemas abiertos de la consulta 13 debe coincidir con la aplicación Problems en el mismo periodo.
  4. Vigila el volumen de datos analizado que se muestra tras la ejecución: una consulta que barre terabytes merece un filtro antes en el pipeline.

Buenas prácticas

  • Filtrar pronto: coloca filter justo después de fetch y reduce la ventana. La consulta es más rápida y cuesta menos.
  • Siempre un límite al explorar: limit evita traer millones de filas.
  • Un Notebook compartido por equipo, con estas consultas comentadas: la guardia parte de una base común.
  • Nombrar los campos calculados (errors = count()): los gráficos y las exportaciones se vuelven legibles.
  • Versionar las consultas que alimentan un SLO o una alerta, como si fueran código.

Preguntas frecuentes

¿Funcionan estas consultas en Dynatrace Managed?

No. DQL y Grail son propios de la plataforma SaaS. En Managed, usa el Data Explorer y los metric selectors de la API v2 (/api/v2/metrics/query) para las métricas, y el visor de logs para las búsquedas de texto.

¿Por qué mi consulta sobre spans no devuelve nada?

Comprueba la ventana y después los campos: request.is_root_span y dt.entity.service se rellenan para los servicios detectados por Dynatrace. Los spans de OpenTelemetry puros pueden exponer solo service.name.

¿Consume presupuesto una consulta DQL?

Según tu modelo de licencia, el análisis de datos puede facturarse por volumen leído. Consulta tu contrato y la documentación de precios; filtrar pronto sigue siendo el mejor ahorro.

Conclusión

Quince consultas cubren lo esencial de la operación: errores, latencia, saturación, problemas y MTTR. Guárdalas en un Notebook de equipo, adapta los nombres de campos a tus fuentes y cada incidente arrancará con ventaja.

span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Dynatrace es una marca de su propietario. Los nombres de campos y de métricas evolucionan: compruébalos 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
Token API Dynatrace : dépanner les scopes et les erreurs 401 et 403 (OTLP, API v2)

Token de API de Dynatrace: solucionar problemas de scopes y errores 401 y 403 (OTLP, API v2)

Next Post
Workflow Dynatrace Jira ou ServiceNow : ouvrir un ticket automatiquement sur problème

Workflow de Dynatrace con Jira o ServiceNow: abrir un ticket automáticamente ante un problema

Related Posts