DQL avanzado: lookup, join, parse y funciones de ventana

DQL avanzado: enriquece con lookup, correlaciona con join, estructura los logs con parse y suaviza las series con las funciones móviles de Grail.
DQL avancé : lookup, join, parse et fonctions de fenêtre

Durante un incidente, la consulta que responde a la pregunta nunca es un simple fetch | filter | summarize. Hay que asociar un error al equipo responsable, relacionar un evento de negocio con los logs de la misma traza, extraer un identificador enterrado en un mensaje o suavizar una serie ruidosa para ver la tendencia. Ese es el terreno del DQL avanzado.

Cuatro herramientas cubren lo esencial: lookup para enriquecer, join para correlacionar, parse para estructurar y las funciones móviles sobre arrays para razonar en el tiempo. Bien dominadas, reducen el MTTR: menos idas y venidas entre pantallas y una sola consulta compartida en el Notebook del incidente.

El objetivo de este tutorial es escribir, para cada una de estas herramientas, una consulta útil en operaciones y saber verificar su resultado. El contenido vale para Dynatrace SaaS (Grail y DQL); Dynatrace Managed no ejecuta DQL sobre Grail.

Requisitos previos

  • Un entorno Dynatrace SaaS con Grail y acceso a Notebooks.
  • Las bases de DQL: fetch, filter, fields, summarize (consulta el módulo sobre los fundamentos de DQL).
  • Logs y spans ingeridos, idealmente con trace_id informado en los logs.

lookup o join: ¿cuál es la diferencia?

lookup join
Uso Enriquecer cada fila con atributos de una tabla de referencia Combinar dos conjuntos de datos según una condición
Coincidencias múltiples Solo se conserva el primer registro coincidente Una fila por cada par coincidente: el volumen puede aumentar
Prefijo por defecto de los campos añadidos lookup. right.
Filas sin coincidencia Se conservan, con los campos añadidos a null Según kind: inner, leftOuter, outer

Regla sencilla: si quieres «una columna más», usa lookup. Si quieres «poner dos historias una al lado de la otra», usa join.

DQL avanzado en la práctica: cuatro consultas paso a paso

Paso 1: enriquecer con lookup

Una tabla de referencia almacenada en Grail (un archivo de lookup cargado con load) traduce un código técnico en información legible. Ejemplo: añadir la etiqueta de cada código HTTP a los spans.

fetch spans, from:now()-1h
| filter isNotNull(http.response.status_code)
| lookup [ load "/lookups/http_status_codes" ],
    sourceField: http.response.status_code,
    lookupField: code,
    prefix: "status."
| summarize nb = count(), by:{ http.response.status_code, status.label }
| sort nb desc

Líneas clave: sourceField designa el campo de la consulta principal y lookupField el de la tabla. El prefix evita colisiones de nombres; sin él, los campos llegan con el prefijo lookup.. Aquí, status.label supone que tu archivo contiene una columna label: adáptalo al contenido real.

La tabla también puede ser una subconsulta. Para asociar a cada host el número de eventos de negocio emitidos:

fetch dt.entity.host
| fields id, entity.name
| lookup [ fetch bizevents
          | summarize events = count(), by:{ dt.entity.host } ],
    sourceField: id, lookupField: dt.entity.host, prefix: "biz."

Paso 2: correlacionar con join

Un evento de negocio ha fallado; ¿qué decían los logs de la misma traza? join une las dos fuentes por trace_id:

fetch bizevents, from:now()-2h
| filter event.type == "checkout.failed"
| limit 100
| join [ fetch logs, from:now()-2h | filter loglevel == "ERROR" ],
    kind: leftOuter,
    on: { trace_id },
    executionOrder: leftFirst,
    fields: { log.timestamp = timestamp, content }
| fields timestamp, trace_id, log.timestamp, content

Líneas clave: kind: leftOuter conserva los eventos sin log correspondiente (campos a null), lo que también revela huecos de instrumentación. executionOrder: leftFirst ejecuta primero el lado izquierdo, limitado a 100 filas, lo que evita superar el límite de tamaño del lado derecho. fields solo trae las columnas útiles. Cuando los nombres difieren, escribe on: left[dt.entity.host] == right[id].

Paso 3: estructurar con parse

Un log de aplicación contiene la información, pero dentro de una frase. parse aplica un patrón DPL (Dynatrace Pattern Language) y crea campos tipados:

fetch logs, from:now()-3h
| filter contains(content, "AddItemAsync")
| parse content, "LD 'userId=' LD:userId ', productId=' LD:productId ', quantity=' INT:productQuantity"
| summarize total = sum(productQuantity), by:{ productId }
| sort total desc
| limit 10

Líneas clave: LD consume texto hasta el siguiente literal, INT captura un entero tipado y el nombre tras : pasa a ser el campo. Para un log JSON, el matcher JSON extrae directamente las claves deseadas:

| parse content, "JSON{ STRING:path, INT:integrationLatency }(flat=true)"

Si un patrón aparece en todas tus consultas, muévelo a la ingesta, en OpenPipeline: lo pagarás una vez en lugar de recalcularlo en cada lectura. El análisis de patrones de logs ayuda a encontrar esos patrones recurrentes.

Paso 4: razonar en el tiempo con las funciones móviles

DQL no tiene una cláusula OVER como SQL. El equivalente pasa por las series temporales: timeseries o makeTimeseries producen arrays, y las funciones arrayMovingAvg, arrayMovingMax, arrayMovingMin, arrayMovingSum, arrayDelta o arrayCumulativeSum calculan una ventana sobre esos arrays.

timeseries cpu = avg(dt.host.cpu.usage), interval:1m, by:{ dt.entity.host }
| fieldsAdd cpu_5m = arrayMovingAvg(cpu, 5)
| fieldsAdd pic_5m = arrayMovingMax(cpu, 5)

Con un intervalo de un minuto, una ventana de 5 elementos da una media móvil de cinco minutos. La ventana se expresa en número de puntos, no en duración, y tiene un tope de 60. Los primeros puntos no tienen historial completo: amplía from: para no interpretarlos.

El mismo principio sobre logs, pasando por makeTimeseries:

fetch logs, from:now()-6h
| filter loglevel == "ERROR"
| makeTimeseries erreurs = count(), interval:5m
| fieldsAdd tendance = arrayMovingAvg(erreurs, 6),
            variation = arrayDelta(erreurs)

Cómo comprobar que funciona

  • lookup: cuenta las filas antes y después; el número debe ser idéntico. Después filtra isNull(status.label) para listar los códigos ausentes de la tabla.
  • join: compara count() antes y después. Un aumento fuerte señala coincidencias múltiples; un valor nulo en content señala logs sin trace_id (consulta las consultas DQL de operaciones para otras comprobaciones).
  • parse: añade | filter isNull(productId) | limit 20 para ver las líneas que el patrón no reconoce.
  • funciones móviles: muestra la serie original y la serie suavizada en el mismo gráfico del Notebook; la segunda debe seguir a la primera con un retraso visible.

Buenas prácticas

  • Filtra antes de enriquecer: filter y limit antes de join o lookup reducen el volumen leído y el coste de la consulta.
  • Nombra los prefijos: prefix: "biz." se lee mejor que lookup. seis meses después.
  • Acota el tiempo en ambos lados de un join: una subconsulta sin from: usa la ventana por defecto, que no es necesariamente la de la consulta principal.
  • Versiona las consultas de incidente en un Notebook compartido: se convierten en un runbook.

Preguntas frecuentes

¿Por qué mi join devuelve más filas que el origen?

Cada fila de la izquierda se repite por cada coincidencia de la derecha. Deduplica el lado derecho con summarize o dedup, o pasa a lookup si basta una sola coincidencia.

¿Dónde almaceno una tabla de referencia para lookup?

En un archivo de lookup cargado en Grail, leído con load "/lookups/...". Para una tabla que cambia a menudo, una subconsulta sobre eventos o entidades evita mantener un archivo.

¿Se puede hacer una media móvil sobre una duración en lugar de un número de puntos?

No directamente: la ventana cuenta elementos. Fija interval en timeseries o makeTimeseries y calcula después el número de puntos que corresponde a la duración deseada.

Conclusión

lookup enriquece sin duplicar, join correlaciona dos fuentes, parse convierte un mensaje en datos y las funciones móviles dan la tendencia. Estas cuatro herramientas cubren la mayoría de las preguntas de un incidente. Guarda las consultas que te hayan servido: la próxima investigación partirá con ventaja.

span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Dynatrace es una marca de Dynatrace LLC. La sintaxis de DQL evoluciona: comprueba siempre los comandos y parámetros 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
RUM Dynatrace : configurer le Real User Monitoring et lire les Core Web Vitals

RUM de Dynatrace: configurar el Real User Monitoring y leer los Core Web Vitals

Next Post
OpenPipeline masquage : filtrer, masquer les données sensibles et réduire le coût

Enmascaramiento con OpenPipeline: filtrar, ocultar datos sensibles y reducir el coste

Related Posts