Requêtes DQL exemples : 15 requêtes prêtes à copier avec DQL summarize, filter et timeseries

Requêtes DQL exemples pour l’astreinte : 15 requêtes prêtes à copier sur les logs, spans, hôtes, problèmes et MTTR, avec conseils pour les adapter.
Requêtes DQL exemples : 15 requêtes prêtes à copier avec DQL summarize, filter et timeseries

À trois heures du matin, personne n’a envie d’écrire une requête depuis zéro. Ces requêtes DQL exemples couvrent les questions que l’astreinte se pose chaque semaine : quels services échouent, quels hôtes saturent, quels problèmes restent ouverts, combien de temps on met à les fermer. La plupart reposent sur DQL summarize, qui regroupe les enregistrements partageant les mêmes valeurs et les agrège : comptage, moyenne, centile par service ou par hôte.

Avoir ces requêtes prêtes dans un Notebook réduit le temps de diagnostic, donc le MTTR, et supprime une part du toil : on ne réinvente plus la même requête à chaque incident. Elles servent aussi de base aux indicateurs SLI d’un SLO.

Objectif : repartir avec 15 requêtes testables, classées par usage, et savoir les adapter. Périmètre : DQL interroge Grail, donc ces requêtes valent pour Dynatrace SaaS uniquement. Dynatrace Managed n’a pas Grail ; ses équivalents passent par le Data Explorer, les sélecteurs de métriques et l’API v2, évoqués en fin d’article.

Prérequis

  • Un environnement Dynatrace SaaS avec Grail, et l’accès aux Notebooks ou aux Dashboards.
  • Les permissions de lecture sur les tables concernées (logs, spans, événements, métriques) ; elles dépendent de votre politique IAM.
  • Des données réellement ingérées : OneAgent, Collector OpenTelemetry ou les deux.
  • Les bases du langage : si fetch, filter et summarize ne vous disent rien, commencez par les fondamentaux de DQL.

Un avertissement important : les noms de champs dépendent de la source. Un log envoyé par OneAgent et un log reçu en OTLP n’ont pas toujours les mêmes attributs. Avant de copier une requête, lancez fetch logs | limit 5 (ou spans) et vérifiez que les champs utilisés existent chez vous.

Requêtes DQL exemples pour les logs

1. Top des sources d’erreurs sur la dernière heure

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

Un enregistrement sans host.name n’est pas écarté : summarize le place dans un groupe null à part, à vérifier avant de lire le top 10. Remplacez host.name par k8s.namespace.name ou service.name selon ce que vos logs portent.

2. Courbe des erreurs sur 24 heures

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

makeTimeseries transforme des enregistrements en série temporelle, affichable directement en graphique. Une marche nette sur la courbe date souvent un déploiement.

3. Chercher un message précis

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

4. Extraire un code de statut du texte

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

La commande parse utilise le Dynatrace Pattern Language : LD consomme le texte jusqu’au littéral, INT:status capture l’entier dans un nouveau champ. Pour industrialiser ce type d’extraction, voir l’analyse de patterns de logs.

5. Volume de logs par source

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

Utile pour repérer une source bavarde avant qu’elle ne pèse sur la facture d’ingestion.

DQL summarize : exemples pour les traces et services

6. Latence p95 par service

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

Le filtre sur request.is_root_span ne garde que le span d’entrée de chaque requête dans un service : on mesure ce que l’appelant perçoit, pas chaque appel interne.

7. Taux d’erreur par service

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

C’est la forme d’un SLI de disponibilité. Pour en faire un SLO, voir choisir ses SLI avec DQL.

8. Retrouver une trace à partir de son identifiant

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

Pratique quand un identifiant de trace remonte dans un log ou un ticket.

9. Endpoints les plus lents

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

Le filtre sur calls écarte les endpoints rares, dont le percentile n’a pas de sens statistique.

Infrastructure

10. Hôtes au-dessus de 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 lit les métriques ; arrayAvg calcule la moyenne de la série sur la période pour filtrer.

11. Mémoire des hôtes

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. Redémarrages de conteneurs 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

Le nom de la métrique dépend de votre version de l’intégration Kubernetes : vérifiez-le dans le navigateur de métriques ou sur docs.dynatrace.com avant de l’utiliser.

Problèmes et événements

13. Problèmes ouverts maintenant

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 semaine

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 différence entre deux horodatages donne une durée, convertie ici en nanosecondes par toLong, puis en minutes. Le p90 dit plus que la moyenne : quelques incidents longs suffisent à la fausser. Cette requête nourrit directement une revue d’incident, voir le postmortem sans blâme avec DQL.

15. Problèmes par catégorie sur 30 jours

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

Une catégorie qui grossit de mois en mois signale une dette de fiabilité. Si le volume vient surtout du bruit, lisez réduire le bruit des alertes Davis.

Comment vérifier que ça fonctionne

  1. Ouvrez un Notebook, collez une requête et exécutez-la. Un tableau vide n’est pas une erreur : élargissez d’abord la fenêtre (from:now()-7d).
  2. Si l’éditeur signale un champ inconnu, lancez fetch logs | limit 5 ou fetch spans | limit 5 et comparez les noms réels.
  3. Comparez un chiffre avec un écran connu : le nombre de problèmes ouverts de la requête 13 doit correspondre à l’application Problems sur la même période.
  4. Surveillez le volume de données analysé affiché après l’exécution : une requête qui balaie des téraoctets mérite un filtre plus tôt dans le pipeline.

Bonnes pratiques

  • Filtrer tôt : placez filter juste après fetch et réduisez la fenêtre. La requête est plus rapide et coûte moins.
  • Toujours une limite en exploration : limit évite de rapatrier des millions de lignes.
  • Un Notebook partagé par équipe, avec ces requêtes commentées : l’astreinte part d’une base commune.
  • Nommer les champs calculés (errors = count()) : les graphiques et les exports deviennent lisibles.
  • Versionner les requêtes qui alimentent un SLO ou une alerte, comme du code.

Questions fréquentes

Ces requêtes fonctionnent-elles sur Dynatrace Managed ?

Non. DQL et Grail sont propres à la plateforme SaaS. En Managed, utilisez le Data Explorer et les sélecteurs de métriques de l’API v2 (/api/v2/metrics/query) pour les métriques, et la visionneuse de logs pour les recherches de texte.

Pourquoi ma requête sur les spans ne renvoie rien ?

Vérifiez la fenêtre, puis les champs : request.is_root_span et dt.entity.service sont renseignés pour les services détectés par Dynatrace. Des spans OpenTelemetry purs peuvent n’exposer que service.name.

Une requête DQL consomme-t-elle du budget ?

Selon votre modèle de licence, l’analyse des données peut être facturée au volume lu. Consultez votre contrat et la documentation de tarification ; filtrer tôt reste la meilleure économie.

Conclusion

Quinze requêtes couvrent l’essentiel de l’exploitation : erreurs, latence, saturation, problèmes et MTTR. Rangez-les dans un Notebook d’équipe, adaptez les noms de champs à vos sources, et chaque incident démarre avec une longueur d’avance.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de son propriétaire. Les noms de champs et de métriques évoluent : vérifiez-les dans votre environnement et dans la documentation officielle.

Total
0
Shares
Laisser un commentaire

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

Previous Post
Token API Dynatrace : dépanner les scopes et les erreurs 401 et 403 (OTLP, API v2)

Token API Dynatrace : dépanner les scopes et les erreurs 401 et 403 (OTLP, API v2)

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

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

Related Posts