Module 3 du parcours métriques Dynatrace Managed : 20 métriques service builtin (clés builtin:service.*) pour suivre le trafic, la latence, les erreurs, les requêtes clés et les appels aux bases de données, avec une requête metric selector par fiche.
Parcours : Formation aux métriques Dynatrace Managed · Module 3/7 · Domaine : services, requêtes, bases de données · Plateforme : Dynatrace Managed (Metrics API v2, metric selector)
Les utilisateurs ne voient pas un hôte, ils voient un service qui répond lentement ou en erreur. Les métriques de service portent donc les signaux d’or : trafic, latence, erreurs, et une partie de la saturation à travers les temps passés en base ou en attente. Ce sont elles qui alimentent la plupart des SLO.
Le module 2 a couvert les hôtes ; ce module monte d’un étage. Les fiches suivent toutes le même plan : mesure, usage, piège, requête.
Le contenu vaut pour Dynatrace Managed et pour les métriques classiques de Dynatrace SaaS. Sur Grail, les clés deviennent dt.service.* et s’interrogent en DQL.
Services : le tableau récapitulatif
Source : page Built-in metrics de la documentation Managed. La dimension principale est dt.entity.service ; les métriques keyRequest se découpent par requête clé (dt.entity.service_method). Point d’attention : les temps sont en microsecondes.
| Clé | Unité | Agrégations | Ce qu’elle mesure |
|---|---|---|---|
builtin:service.requestCount.total |
Count | value | Requêtes reçues |
builtin:service.requestCount.server |
Count | value | Requêtes mesurées côté serveur |
builtin:service.response.time |
Microseconde | avg, count, max, median, min, percentile, sum | Temps de réponse |
builtin:service.response.server |
Microseconde | avg, count, max, median, min, percentile, sum | Temps de réponse côté serveur |
builtin:service.errors.total.count |
Count | value | Requêtes en échec (toutes) |
builtin:service.errors.total.rate |
% | avg | Taux d’échec (toutes) |
builtin:service.errors.server.count |
Count | value | Échecs côté serveur |
builtin:service.errors.server.rate |
% | avg | Taux d’échec côté serveur |
builtin:service.errors.fivexx.count |
Count | value | Réponses HTTP 5xx |
builtin:service.errors.fourxx.count |
Count | value | Réponses HTTP 4xx |
builtin:service.successes.server.rate |
% | avg | Taux de succès côté serveur |
builtin:service.cpu.time |
Microseconde | value | CPU consommé par le service |
builtin:service.cpu.perRequest |
Microseconde | avg, count, max, min, sum | CPU par requête |
builtin:service.dbChildCallCount |
Count | value | Appels aux bases de données |
builtin:service.dbChildCallTime |
Microseconde | value | Temps passé en base |
builtin:service.nonDbChildCallCount |
Count | value | Appels à d’autres services |
builtin:service.dbconnections.failureRate |
% | value | Échecs de connexion à la base |
builtin:service.keyRequest.response.time |
Microseconde | avg, count, max, median, min, percentile, sum | Temps de réponse d’une requête clé |
builtin:service.keyRequest.count.total |
Count | value | Volume d’une requête clé |
builtin:service.keyRequest.errors.server.rate |
% | avg | Taux d’échec d’une requête clé |
{{img:140-metriques-service-builtin-1.png|Extrait de la page Built-in metrics de la documentation Dynatrace Managed : clés builtin:service.requestCount.total, response.time, errors.server.rate, cpu.time, dbChildCallTime, keyRequest.response.time et dbconnections.failureRate avec unité et agrégations}}
Trafic et latence : les métriques service builtin de base
builtin:service.requestCount.total
Le nombre de requêtes reçues par le service ; la documentation précise qu’elle accepte les découpages de service (splittings). C’est le signal de trafic. Une chute brutale vaut autant d’attention qu’une hausse d’erreurs : elle trahit souvent un problème en amont.
builtin:service.requestCount.total:splitBy("dt.entity.service"):sort(value(sum,descending)):limit(10)
builtin:service.requestCount.server
Le même comptage, mesuré côté serveur uniquement. Il sert de dénominateur cohérent quand on calcule un taux à partir des erreurs côté serveur.
builtin:service.requestCount.server:splitBy("dt.entity.service")
builtin:service.response.time
Le temps que met le service à renvoyer sa réponse, en microsecondes. Préférez un percentile à la moyenne : un p90 décrit l’expérience de la majorité sans être écrasé par quelques requêtes très rapides. Divisez par 1 000 pour lire des millisecondes.
builtin:service.response.time:splitBy("dt.entity.service"):percentile(90):sort(value(max,descending)):limit(10)
builtin:service.response.server
Le temps de réponse côté serveur, sans la part mesurée côté client appelant. L’écart entre les deux révèle un temps réseau ou de file d’attente chez l’appelant.
builtin:service.response.server:splitBy("dt.entity.service"):median
Erreurs et succès
builtin:service.errors.total.count
Les requêtes en échec, mesurées côté serveur ou client. Ce qui compte comme échec dépend de la détection des défaillances configurée pour le service : vérifiez ce réglage avant de bâtir un SLO dessus.
builtin:service.errors.total.count:splitBy("dt.entity.service"):sort(value(sum,descending)):limit(10)
builtin:service.errors.total.rate
Le taux d’échec toutes erreurs confondues, en pourcentage, avec la seule agrégation avg. Pratique pour un tableau de bord ; pour un SLO, calculez plutôt le ratio vous-même afin de maîtriser le dénominateur.
builtin:service.errors.total.rate:splitBy("dt.entity.service"):avg
builtin:service.errors.server.count
Les échecs mesurés côté serveur. C’est le compteur à privilégier pour un indicateur de fiabilité du service lui-même, indépendamment de ses clients.
builtin:service.errors.server.count:splitBy("dt.entity.service")
builtin:service.errors.server.rate
Le taux d’échec côté serveur. Une hausse soudaine après un déploiement est le cas d’usage type d’un événement de métrique ou d’une alerte de burn rate.
builtin:service.errors.server.rate:splitBy("dt.entity.service"):avg:sort(value(avg,descending)):limit(10)
builtin:service.errors.fivexx.count
Les réponses HTTP dont le code est compris entre 500 et 599. Elles désignent une défaillance du service ou d’une de ses dépendances.
builtin:service.errors.fivexx.count:splitBy("dt.entity.service")
builtin:service.errors.fourxx.count
Les réponses HTTP 4xx. Piège classique : un pic de 404 ou de 401 vient souvent d’un client mal configuré, pas du service. Ne l’intégrez pas tel quel dans un budget d’erreur.
builtin:service.errors.fourxx.count:splitBy("dt.entity.service")
builtin:service.successes.server.rate
Le taux de succès côté serveur, en pourcentage. C’est la forme la plus directe d’un SLI de disponibilité ; l’article sur les SLO dans Dynatrace Managed montre comment l’utiliser.
builtin:service.successes.server.rate:splitBy("dt.entity.service"):avg
Consommation et dépendances
builtin:service.cpu.time
Le temps CPU consommé par le service, en microsecondes. Il permet de relier une hausse de CPU sur l’hôte à un service précis, et de comparer deux versions d’un même code.
builtin:service.cpu.time:splitBy("dt.entity.service"):sort(value(sum,descending)):limit(10)
builtin:service.cpu.perRequest
Le CPU consommé par requête. Contrairement au total, il ne grimpe pas avec le trafic : une hausse signale une requête devenue plus coûteuse, souvent après un changement de code.
builtin:service.cpu.perRequest:splitBy("dt.entity.service"):avg
builtin:service.dbChildCallCount
Le nombre d’appels aux bases de données faits par le service. Un ratio appels/requête qui explose trahit le motif N+1, fréquent avec les ORM.
builtin:service.dbChildCallCount:splitBy("dt.entity.service") / builtin:service.requestCount.total:splitBy("dt.entity.service")
builtin:service.dbChildCallTime
Le temps passé dans les appels aux bases, en microsecondes. Comparé au temps de réponse, il dit si la lenteur vient de la base ou du code du service.
builtin:service.dbChildCallTime:splitBy("dt.entity.service")
builtin:service.nonDbChildCallCount
Le nombre d’appels vers d’autres services ; nonDbChildCallTime donne le temps correspondant. Une hausse de ce temps oriente l’analyse vers une dépendance en aval. Dans la même famille, builtin:service.ioTime, lockTime et waitTime (microsecondes) détaillent les temps d’entrée-sortie, de verrou et d’attente.
builtin:service.nonDbChildCallCount:splitBy("dt.entity.service")
builtin:service.dbconnections.failureRate
Le taux de tentatives de connexion à une base qui échouent, rapporté à toutes les tentatives. Un pool saturé ou une base injoignable s’y voit avant les erreurs applicatives.
builtin:service.dbconnections.failureRate:splitBy("dt.entity.service")
Requêtes clés
Une requête clé est un point d’entrée que vous marquez comme critique (paiement, connexion). Dynatrace écrit alors des métriques dédiées pour chacune.
builtin:service.keyRequest.response.time
Le temps de réponse d’une requête clé, en microsecondes. C’est le bon grain pour un SLO de latence sur un parcours métier : on évite que des requêtes secondaires diluent le signal.
builtin:service.keyRequest.response.time:splitBy("dt.entity.service_method"):percentile(95)
builtin:service.keyRequest.count.total
Le nombre de requêtes pour une requête clé. Il sert de dénominateur aux SLO et de signal métier : une baisse du volume de paiements se voit ici.
builtin:service.keyRequest.count.total:splitBy("dt.entity.service_method")
builtin:service.keyRequest.errors.server.rate
Le taux d’échec côté serveur d’une requête clé. Associé au temps de réponse, il couvre les deux SLI les plus utilisés sur un point d’entrée critique.
builtin:service.keyRequest.errors.server.rate:splitBy("dt.entity.service_method"):avg
Comment vérifier que ça fonctionne
- Listez les clés de service disponibles :
curl -s "$DT_URL/api/v2/metrics?metricSelector=builtin:service.*&fields=unit,aggregationTypes" \ -H "Authorization: Api-Token $DT_TOKEN" - Interrogez une requête du module :
curl -s -G "$DT_URL/api/v2/metrics/query" \ --data-urlencode 'metricSelector=builtin:service.response.time:splitBy("dt.entity.service"):percentile(90)' \ --data-urlencode 'from=now-2h' \ -H "Authorization: Api-Token $DT_TOKEN" - Comparez une valeur au graphique de la page du service : en divisant par 1 000, les microsecondes doivent correspondre aux millisecondes affichées.
Les métriques keyRequest ne renvoient rien tant qu’aucune requête n’est marquée comme clé. La syntaxe du metric selector est détaillée dans le module metric selector et API.
Bonnes pratiques
- Lisez les temps en microsecondes, et convertissez avant de comparer à un objectif en millisecondes.
- Utilisez un percentile pour la latence, un ratio succès/total pour la disponibilité.
- Séparez 4xx et 5xx : seuls les seconds reflètent en général la fiabilité du service.
- Marquez vos parcours critiques en requêtes clés pour obtenir des métriques au bon grain.
Questions fréquentes
Quelle différence entre errors.total et errors.server ?
La première compte les échecs mesurés côté serveur ou client, la seconde seulement côté serveur. Pour juger le service lui-même, partez du côté serveur.
Où sont les bases de données dans ce module ?
Vues depuis le service appelant : appels, temps et échecs de connexion. Les métriques internes d’un moteur de base relèvent des extensions (module 6).
Ces clés existent-elles sur Grail ?
Des équivalents dt.service.* existent sur Dynatrace SaaS avec Grail, avec des noms et des unités parfois différents ; le parcours métriques SaaS les traite.
Avec les hôtes et les services, vous tenez les deux étages côté serveur. Le module suivant passe du côté des utilisateurs : applications web et mobiles, Apdex et moniteurs synthétiques.
← Module 2 : hôtes · Sommaire du parcours · Module 4 : applications →
span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Les clés et unités citées proviennent de la documentation officielle Dynatrace Managed ; vérifiez-les dans la version de votre cluster.