Dashboard Dynatrace SaaS : construire des tableaux de bord DQL sur Grail, avec 3 exemples complets

Dashboard Dynatrace SaaS : tuiles, variables et requêtes DQL, puis trois exemples complets (services, Kubernetes, logs) à importer ou versionner.
Dashboard Dynatrace SaaS : construire des tableaux de bord DQL sur Grail, avec 3 exemples complets

Un incident commence, et l’astreinte ouvre trois écrans : la liste des services, l’application Kubernetes, puis les logs. Chaque écran a sa propre plage de temps et ses propres filtres. Les minutes passent avant d’avoir une vue d’ensemble. Un dashboard Dynatrace SaaS bien construit rassemble ces signaux sur une seule page, avec les mêmes filtres pour toutes les tuiles.

Sur la plateforme SaaS récente, les tableaux de bord vivent dans l’application Dashboards et interrogent Grail en DQL. Chaque tuile est une requête lisible, versionnable et réutilisable dans un Notebook. C’est un vrai gain de MTTR : la requête qui a servi au diagnostic devient la tuile que toute l’équipe consulte ensuite.

Objectif de ce tutoriel : comprendre le vocabulaire (tuiles, variables, visualisations), créer un dashboard pas à pas, puis reproduire trois exemples complets, décrits tuile par tuile avec leur requête DQL. Le contenu vaut pour Dynatrace SaaS avec Grail. Dynatrace Managed n’a pas l’application Dashboards ni Grail : il garde les dashboards classiques, traités dans un article séparé.

Le vocabulaire d’un dashboard Dynatrace SaaS

Avant de cliquer, fixons les mots. Ils reviennent dans l’interface comme dans le JSON du dashboard.

Élément Rôle Dans le JSON
Tuile de données Exécute une requête DQL et affiche le résultat "type": "data", avec query et visualization
Tuile Markdown Texte, consignes d’astreinte, liens vers les runbooks "type": "markdown"
Tuile de code Récupère des données avec une fonction JavaScript Tuile de type code
Variable Filtre commun (liste, texte, requête) référencé par $cle Tableau variables
Visualisation Courbe, barres, valeur unique, tableau… visualization et visualizationSettings

Les dashboards proposent aussi les segments. La documentation conseille les segments pour des filtres réutilisés entre plusieurs dashboards, et les variables quand il faut contrôler finement l’opérateur du filtre ou l’enchaînement de filtres dépendants.

Si vous débutez avec DQL, commencez par les bases présentées dans le module Notebooks et Dashboards de la formation SaaS, puis gardez sous la main notre recueil de requêtes DQL d’exploitation.

Prérequis

  • Un environnement Dynatrace SaaS avec Grail et l’application Dashboards.
  • Les droits de lecture sur les données interrogées (métriques, logs) dans Grail : vérifiez les politiques IAM de votre groupe.
  • Des données présentes : services instrumentés (OneAgent ou OpenTelemetry), un cluster Kubernetes surveillé, des logs ingérés.
  • Pour le provisionnement : un client OAuth avec les permissions document:documents:read, document:documents:write, document:documents:delete et document:trash.documents:delete (Terraform), ou Monaco.

Créer le dashboard en cinq étapes

  1. Ouvrez Dashboards, puis créez un nouveau dashboard et donnez-lui un nom explicite (« Santé services – prod »).
  2. Ajoutez une tuile de données (raccourci Shift + D), collez la requête DQL et exécutez-la (Ctrl/Cmd + Entrée).
  3. Choisissez la visualisation dans le panneau latéral et réglez unités, seuils et légende.
  4. Ajoutez les variables : leur clé, préfixée par $, s’utilise ensuite dans les requêtes et les titres. Une clé ne peut pas commencer par dt_.
  5. Ajoutez une tuile Markdown (Shift + M) avec le lien vers le runbook et le propriétaire du dashboard.

Exemple 1 : santé des services (requêtes, erreurs, latence p95)

Ce dashboard répond à la question « mes services tiennent-ils leur SLO ? ». Il s’appuie sur les métriques de service Grail dt.service.request.count (avec la dimension booléenne failed) et dt.service.request.response_time.

Tuile 1 – Requêtes totales (valeur unique, sparkline activée) :

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

Tuile 2 – Taux d’échec par service (courbe, seuil visuel à votre objectif d’erreur) :

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

Les lignes critiques : default: 0.0 évite les trous quand un service n’a aucun échec, et l’opérateur [] divise les deux séries point par point.

Tuile 3 – Latence p95 par service (courbe) :

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

Tuile 4 – Top 10 des services les plus lents (tableau) :

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

Vérifiez l’unité de la latence dans le panneau de la tuile avant de fixer des seuils. Pour transformer ces indicateurs en objectifs suivis par la direction, reprenez la démarche du tableau de bord SLO pour la direction.

Exemple 2 : infrastructure Kubernetes avec la variable $namespace

Créez d’abord une variable de type requête, clé namespace, sélection multiple activée :

smartscapeNodes "K8S_NAMESPACE"
| fields name
| sort name asc

Une variable à sélection multiple s’utilise avec in() et array(), comme dans toutes les tuiles ci-dessous.

Tuile 1 – CPU par namespace (courbe empilée ou aires) :

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

Tuile 2 – Mémoire (working set) par namespace (courbe) :

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

Tuile 3 – Workloads dont les conteneurs ont redémarré (tableau) :

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 dimension k8s.workload.name ne remonte pas sur votre cluster, regroupez par k8s.namespace.name seul et consultez les dimensions disponibles dans le navigateur de métriques.

Tuile 4 – Pods par phase (barres empilées) :

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

Un pic de pods en phase Pending ou Failed à côté d’une hausse de redémarrages pointe souvent vers des limites mémoire trop basses (OOM kills).

Exemple 3 : logs (volume par niveau, top erreurs)

Variable de type requête, clé loglevel, sélection multiple :

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

Tuile 1 – Volume de logs par niveau dans le temps (barres empilées) :

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

Tuile 2 – Répartition par niveau (barres catégorielles) :

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

Tuile 3 – Nombre d’erreurs (valeur unique) :

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

Tuile 4 – Top 10 des messages d’erreur (tableau) :

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

Les messages contiennent souvent des identifiants variables qui éclatent le regroupement. Extrayez la partie stable avec parse, comme expliqué dans notre article sur le DQL avancé : lookup, join et parse. Sur de gros volumes, ajoutez une limite de lecture (scanLimitGBytes) pour maîtriser le coût des requêtes.

Partager, exporter et importer le JSON

Le propriétaire d’un dashboard le partage de trois façons : accès en lecture pour tous, liste d’utilisateurs ou de groupes, ou liens de partage. Un partage externe par lien anonyme existe aussi, avec date d’expiration et liste d’IP autorisées.

Le menu du dashboard propose Download, qui écrit la définition JSON dans un fichier ; le panneau latéral Dashboards propose Upload pour l’importer. Extrait d’une tuile et d’une variable dans ce 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": {}
    }
  }
}

Ne réécrivez pas tout le fichier à la main : construisez le dashboard dans l’interface, téléchargez-le, puis versionnez le JSON obtenu.

Provisionner avec Terraform ou Monaco

Le fournisseur Terraform de Dynatrace expose la ressource dynatrace_document, réservée à SaaS, qui gère dashboards, notebooks et launchpads. Elle s’authentifie avec les variables DT_CLIENT_ID, DT_CLIENT_SECRET et DT_ACCOUNT_ID d’un client OAuth :

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

Avec Monaco, le type de configuration document accepte kind: dashboard :

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

Choisissez un seul outil par dashboard : deux pipelines qui écrivent le même document finissent toujours par s’écraser.

Comment vérifier que ça fonctionne

  • Chaque tuile affiche des données sur la plage « dernières 2 heures » ; une tuile vide signale une métrique absente ou un filtre trop strict.
  • Changez la valeur de $namespace : toutes les tuiles Kubernetes se recalculent. Si une tuile ne bouge pas, sa requête ne référence pas la variable.
  • Collez chaque requête dans un Notebook pour lire le résultat brut et ses champs.
  • Après un terraform apply ou un déploiement Monaco, ouvrez le dashboard dans l’application et comparez-le avec le JSON versionné.

Bonnes pratiques

  • Un dashboard, une question : santé des services, capacité Kubernetes ou bruit des logs, pas les trois mélangés.
  • En haut, les indicateurs liés aux SLO ; en dessous, les tuiles de diagnostic.
  • Variables plutôt que copies : un seul dashboard filtré par namespace vaut mieux que dix dashboards dupliqués.
  • Une tuile Markdown avec propriétaire, runbook et date de revue : un dashboard sans propriétaire devient du toil.
  • Limitez les requêtes de logs coûteuses (filtres tôt, limit, plage de temps raisonnable).

Questions fréquentes

Puis-je migrer mes anciens dashboards vers l’application Dashboards ?

Les dashboards classiques n’utilisent pas DQL. La documentation Dynatrace décrit des outils et des équivalences de métriques pour la migration ; dans la pratique, réécrire les tuiles importantes en DQL est souvent l’occasion de les simplifier.

Pourquoi ma variable affiche-t-elle une option vide après duplication ?

Pour une variable à sélection multiple, la valeur par défaut « tout sélectionner » ne s’écrit pas avec une étoile littérale dans le JSON. Sélectionnez la valeur dans l’interface puis téléchargez le JSON au lieu de l’écrire à la main.

Ce tutoriel fonctionne-t-il sur Dynatrace Managed ?

Non. Grail, DQL et l’application Dashboards sont propres à la plateforme SaaS. Sur Managed, les dashboards classiques s’appuient sur des sélecteurs de métriques et l’API de configuration des dashboards.

Conclusion

Un dashboard Dynatrace SaaS efficace tient en quelques tuiles DQL claires, filtrées par des variables communes, et versionnées comme du code. Partez des trois exemples, adaptez les seuils à vos SLO, puis provisionnez le résultat avec Terraform ou Monaco. Pour aller plus loin, consultez la documentation officielle de Dashboards.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de son propriétaire. Les exemples sont fournis à titre indicatif : vérifiez-les sur votre environnement avant de les utiliser en production.

Total
0
Shares
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

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

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

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

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

Related Posts