À 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,filteretsummarizene 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
- 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). - Si l’éditeur signale un champ inconnu, lancez
fetch logs | limit 5oufetch spans | limit 5et comparez les noms réels. - 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.
- 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
filterjuste aprèsfetchet 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.