Dashboard Dynatrace SaaS: construir dashboards DQL sobre Grail, con 3 ejemplos completos

Dashboard Dynatrace SaaS: tiles, variables y consultas DQL, y tres ejemplos completos (servicios, Kubernetes, logs) para importar o versionar.
Dashboard Dynatrace SaaS : construire des tableaux de bord DQL sur Grail, avec 3 exemples complets

Empieza un incidente y la guardia (on-call) abre tres pantallas: la lista de servicios, la aplicación de Kubernetes y después los logs. Cada pantalla tiene su propio rango de tiempo y sus propios filtros. Pasan los minutos antes de tener una visión de conjunto. Un dashboard Dynatrace SaaS bien construido reúne esas señales en una sola página, con los mismos filtros para todos los tiles.

En la plataforma SaaS reciente, los dashboards viven en la aplicación Dashboards y consultan Grail en DQL. Cada tile es una consulta legible, versionable y reutilizable en un Notebook. Es una ganancia real de MTTR: la consulta que sirvió para el diagnóstico se convierte en el tile que consulta después todo el equipo.

Objetivo de este tutorial: entender el vocabulario (tiles, variables, visualizaciones), crear un dashboard paso a paso y después reproducir tres ejemplos completos, descritos tile por tile con su consulta DQL. El contenido vale para Dynatrace SaaS con Grail. Dynatrace Managed no tiene la aplicación Dashboards ni Grail: conserva los dashboards clásicos, tratados en un artículo aparte.

El vocabulario de un dashboard Dynatrace SaaS

Antes de hacer clic, fijemos las palabras. Aparecen tanto en la interfaz como en el JSON del dashboard.

Elemento Función En el JSON
Tile de datos Ejecuta una consulta DQL y muestra el resultado "type": "data", con query y visualization
Tile Markdown Texto, instrucciones de guardia, enlaces a los runbooks "type": "markdown"
Tile de código Obtiene datos con una función JavaScript Tile de tipo código
Variable Filtro común (lista, texto, consulta) referenciado con $clave Array variables
Visualización Curva, barras, valor único, tabla… visualization y visualizationSettings

Los dashboards también ofrecen los segmentos. La documentación recomienda los segmentos para filtros reutilizados entre varios dashboards, y las variables cuando hace falta controlar con precisión el operador del filtro o el encadenamiento de filtros dependientes.

Si empiezas con DQL, comienza por las bases que presenta el módulo Notebooks y Dashboards del curso SaaS y ten a mano nuestra colección de consultas DQL de operaciones.

Requisitos previos

  • Un entorno Dynatrace SaaS con Grail y la aplicación Dashboards.
  • Permisos de lectura sobre los datos consultados (métricas, logs) en Grail: comprueba las políticas IAM de tu grupo.
  • Datos presentes: servicios instrumentados (OneAgent u OpenTelemetry), un clúster Kubernetes monitorizado, logs ingeridos.
  • Para el aprovisionamiento: un cliente OAuth con los permisos document:documents:read, document:documents:write, document:documents:delete y document:trash.documents:delete (Terraform), o Monaco.

Crear el dashboard en cinco pasos

  1. Abre Dashboards, crea un dashboard nuevo y dale un nombre explícito («Salud servicios – prod»).
  2. Añade un tile de datos (atajo Shift + D), pega la consulta DQL y ejecútala (Ctrl/Cmd + Intro).
  3. Elige la visualización en el panel lateral y ajusta unidades, umbrales y leyenda.
  4. Añade las variables: su clave, con el prefijo $, se usa después en las consultas y los títulos. Una clave no puede empezar por dt_.
  5. Añade un tile Markdown (Shift + M) con el enlace al runbook y el propietario del dashboard.

Ejemplo 1: salud de los servicios (peticiones, errores, latencia p95)

Este dashboard responde a la pregunta «¿mis servicios cumplen su SLO?». Se apoya en las métricas de servicio de Grail dt.service.request.count (con la dimensión booleana failed) y dt.service.request.response_time.

Tile 1 – Peticiones totales (valor único, sparkline activada):

timeseries sparkline = sum(dt.service.request.count),
  value = sum(dt.service.request.count, scalar: true)

Tile 2 – Tasa de fallos por servicio (curva, umbral visual en tu objetivo de errores):

timeseries {
  failed = sum(dt.service.request.count, default: 0.0, filter: failed == true),
  total = sum(dt.service.request.count)
}, by: {dt.entity.service}, union: true
| fieldsAdd failure_rate = (failed[] / total[]) * 100
| fieldsAdd service = entityName(dt.entity.service)
| fieldsRemove failed, total

Las líneas críticas: default: 0.0 evita los huecos cuando un servicio no tiene ningún fallo, y el operador [] divide las dos series punto a punto.

Tile 3 – Latencia p95 por servicio (curva):

timeseries p95 = percentile(dt.service.request.response_time, 95),
  by: {dt.entity.service}
| fieldsAdd service = entityName(dt.entity.service)

Tile 4 – Top 10 de los servicios más lentos (tabla):

timeseries p95 = percentile(dt.service.request.response_time, 95),
  by: {dt.entity.service}
| fieldsAdd service = entityName(dt.entity.service), p95_moyen = arrayAvg(p95)
| sort p95_moyen, direction: "descending"
| limit 10

Comprueba la unidad de la latencia en el panel del tile antes de fijar umbrales. Para convertir estos indicadores en objetivos que siga la dirección, retoma el enfoque del dashboard de SLO para la dirección.

Ejemplo 2: infraestructura Kubernetes con la variable $namespace

Crea primero una variable de tipo consulta, clave namespace, con selección múltiple activada:

smartscapeNodes "K8S_NAMESPACE"
| fields name
| sort name asc

Una variable de selección múltiple se usa con in() y array(), como en todos los tiles siguientes.

Tile 1 – CPU por namespace (curva apilada o áreas):

timeseries cpu = sum(dt.kubernetes.container.cpu_usage),
  by: {k8s.namespace.name}
| filter in(k8s.namespace.name, array($namespace))

Tile 2 – Memoria (working set) por namespace (curva):

timeseries memoire = sum(dt.kubernetes.container.memory_working_set),
  by: {k8s.namespace.name}
| filter in(k8s.namespace.name, array($namespace))

Tile 3 – Workloads cuyos contenedores se han reiniciado (tabla):

timeseries restarts = sum(dt.kubernetes.container.restarts),
  by: {k8s.namespace.name, k8s.workload.name}
| filter in(k8s.namespace.name, array($namespace))
| fieldsAdd total = arraySum(restarts)
| filter total > 0
| sort total, direction: "descending"
| limit 20

Si la dimensión k8s.workload.name no aparece en tu clúster, agrupa solo por k8s.namespace.name y consulta las dimensiones disponibles en el navegador de métricas.

Tile 4 – Pods por fase (barras apiladas):

timeseries pods = sum(dt.kubernetes.pods, rollup: avg),
  by: {k8s.namespace.name, pod_phase}
| filter in(k8s.namespace.name, array($namespace))

Un pico de pods en fase Pending o Failed junto a un aumento de reinicios suele apuntar a límites de memoria demasiado bajos (OOM kills).

Ejemplo 3: logs (volumen por nivel, top de errores)

Variable de tipo consulta, clave loglevel, selección múltiple:

fetch logs, from: now() - 2h
| summarize count(), by: {loglevel}
| sort `count()`, direction: "descending"
| fields loglevel

Tile 1 – Volumen de logs por nivel a lo largo del tiempo (barras apiladas):

fetch logs
| filter in(loglevel, array($loglevel))
| makeTimeseries count(), by: {loglevel}

Tile 2 – Reparto por nivel (barras categóricas):

fetch logs
| summarize count(), by: {loglevel}

Tile 3 – Número de errores (valor único):

fetch logs
| summarize erreurs = countIf(loglevel == "ERROR")

Tile 4 – Top 10 de mensajes de error (tabla):

fetch logs
| filter loglevel == "ERROR"
| summarize occurrences = count(), by: {host.name, content}
| sort occurrences, direction: "descending"
| limit 10

Los mensajes suelen contener identificadores variables que fragmentan la agrupación. Extrae la parte estable con parse, como se explica en nuestro artículo sobre DQL avanzado: lookup, join y parse. Con grandes volúmenes, añade un límite de lectura (scanLimitGBytes) para controlar el coste de las consultas.

Compartir, exportar e importar el JSON

El propietario de un dashboard lo comparte de tres formas: acceso de lectura para todos, lista de usuarios o grupos, o enlaces para compartir. También existe un uso compartido externo mediante enlace anónimo, con fecha de caducidad y lista de IP autorizadas.

El menú del dashboard ofrece Download, que escribe la definición JSON en un archivo; el panel lateral Dashboards ofrece Upload para importarlo. Extracto de un tile y de una variable en ese JSON:

{
  "variables": [
    {
      "version": 2,
      "key": "namespace",
      "type": "query",
      "visible": true,
      "editable": true,
      "input": "smartscapeNodes \"K8S_NAMESPACE\" | fields name | sort name asc",
      "multiple": true
    }
  ],
  "tiles": {
    "0": {
      "type": "data",
      "title": "CPU par namespace",
      "query": "timeseries cpu = sum(dt.kubernetes.container.cpu_usage), by: {k8s.namespace.name} | filter in(k8s.namespace.name, array($namespace))",
      "visualization": "lineChart",
      "visualizationSettings": {},
      "querySettings": {}
    }
  }
}

No reescribas todo el archivo a mano: construye el dashboard en la interfaz, descárgalo y versiona después el JSON obtenido.

Aprovisionar con Terraform o Monaco

El proveedor Terraform de Dynatrace expone el recurso dynatrace_document, reservado a SaaS, que gestiona dashboards, notebooks y launchpads. Se autentica con las variables DT_CLIENT_ID, DT_CLIENT_SECRET y DT_ACCOUNT_ID de un cliente OAuth:

resource "dynatrace_document" "k8s" {
  type    = "dashboard"
  name    = "Kubernetes - prod"
  labels  = ["kubernetes", "prod"]
  content = file("${path.module}/dashboards/k8s.json")
}

Con Monaco, el tipo de configuración document acepta kind: dashboard:

configs:
  - id: k8s-dashboard
    type:
      document:
        kind: dashboard
        private: false
    config:
      name: Kubernetes - prod
      template: k8s.json

Elige una sola herramienta por dashboard: dos pipelines que escriben el mismo documento acaban siempre pisándose.

Cómo comprobar que funciona

  • Cada tile muestra datos en el rango «últimas 2 horas»; un tile vacío señala una métrica ausente o un filtro demasiado estricto.
  • Cambia el valor de $namespace: todos los tiles de Kubernetes se recalculan. Si un tile no se mueve, su consulta no referencia la variable.
  • Pega cada consulta en un Notebook para leer el resultado en bruto y sus campos.
  • Tras un terraform apply o un despliegue con Monaco, abre el dashboard en la aplicación y compáralo con el JSON versionado.

Buenas prácticas

  • Un dashboard, una pregunta: salud de los servicios, capacidad de Kubernetes o ruido de los logs, no los tres mezclados.
  • Arriba, los indicadores ligados a los SLO; debajo, los tiles de diagnóstico.
  • Variables en lugar de copias: un único dashboard filtrado por namespace vale más que diez dashboards duplicados.
  • Un tile Markdown con propietario, runbook y fecha de revisión: un dashboard sin propietario se convierte en toil.
  • Limita las consultas de logs costosas (filtros pronto, limit, rango de tiempo razonable).

Preguntas frecuentes

¿Puedo migrar mis dashboards antiguos a la aplicación Dashboards?

Los dashboards clásicos no usan DQL. La documentación de Dynatrace describe herramientas y equivalencias de métricas para la migración; en la práctica, reescribir los tiles importantes en DQL suele ser una ocasión para simplificarlos.

¿Por qué mi variable muestra una opción vacía tras duplicar el dashboard?

En una variable de selección múltiple, el valor por defecto «seleccionar todo» no se escribe con un asterisco literal en el JSON. Selecciona el valor en la interfaz y descarga después el JSON en lugar de escribirlo a mano.

¿Funciona este tutorial en Dynatrace Managed?

No. Grail, DQL y la aplicación Dashboards son propios de la plataforma SaaS. En Managed, los dashboards clásicos se apoyan en metric selectors y en la API de configuración de dashboards.

Conclusión

Un dashboard Dynatrace SaaS eficaz cabe en unos pocos tiles DQL claros, filtrados por variables comunes y versionados como código. Parte de los tres ejemplos, adapta los umbrales a tus SLO y aprovisiona después el resultado con Terraform o Monaco. Para ir más lejos, consulta la documentación oficial de Dashboards.

span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Dynatrace es una marca de Dynatrace LLC. Los ejemplos se ofrecen a título indicativo: comprueba siempre los valores en la documentación oficial correspondiente a tu versión y pruébalos en tu entorno antes de usarlos en producción.

Total
0
Shares
Leave a Reply

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

Previous Post
API Dynatrace Managed : Cluster API v1 et v2, Environment API et schémas Settings disponibles

API de Dynatrace Managed: Cluster API v1 y v2, Environment API y esquemas de Settings disponibles

Next Post
Dashboard Dynatrace Managed : tuiles, Data Explorer et JSON, avec 3 exemples complets

Dashboard Dynatrace Managed: tiles, Data Explorer y JSON, con 3 ejemplos completos

Related Posts