Module 3 — Services : 20 métriques service builtin de Dynatrace Managed

Métriques service builtin de Dynatrace Managed : 20 clés builtin:service pour trafic, latence, erreurs, requêtes clés et bases, avec requêtes prêtes.
Module 3 — Services : 20 métriques service builtin de Dynatrace Managed

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

  1. 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"
  2. 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"
  3. 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.

Total
0
Shares
Laisser un commentaire

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

Previous Post
Module 3 — Métriques de service Grail : requêtes, messagerie et service mesh dt.service.*

Module 3 — Métriques de service Grail : requêtes, messagerie et service mesh dt.service.*

Next Post
Module 4 — Applications : les métriques application builtin, RUM web, mobile et synthétique

Module 4 — Applications : les métriques application builtin, RUM web, mobile et synthétique

Related Posts