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

Métriques application builtin de Dynatrace Managed : 23 fiches Apdex, Core Web Vitals, erreurs, crashs mobiles et synthétique, avec metric selector.
Module 4 — Applications : les métriques application builtin, RUM web, mobile et synthétique

Module 4 du parcours métriques Dynatrace Managed : les métriques application builtin du RUM web et mobile (Apdex, actions utilisateur, Core Web Vitals, erreurs, crashs) et des moniteurs synthétiques, en 23 fiches avec clé exacte, unité, cas d’usage et selector prêt à coller.

Parcours : Formation aux métriques Dynatrace Managed · Module 4/7 · Type : référence · Plateforme : Dynatrace Managed (métriques classiques)

Dans ce module :

  • un tableau récapitulatif des 23 clés, à garder sous la main
  • une fiche par métrique : ce qu’elle mesure, quand l’utiliser, le piège à éviter
  • un metric selector par fiche, testable dans le Data Explorer

Les modules précédents regardent le système de l’intérieur : hôtes, services, bases. Ce module regarde depuis l’utilisateur. Le RUM mesure ce que vivent les vrais visiteurs dans leur navigateur ou leur application mobile ; le synthétique rejoue un parcours à intervalle fixe, même la nuit quand personne ne se connecte. Ensemble, ils fournissent les SLI les plus proches de ce que ressent le client.

Tout ce qui suit vaut pour Dynatrace Managed : clés builtin:apps.* et builtin:synthetic.*, metric selector, API Metrics v2 et Data Explorer. Il n’y a ni Grail ni DQL ici. Sur Dynatrace SaaS avec Grail, le RUM et le synthétique utilisent d’autres clés ; elles sont traitées dans le parcours métriques SaaS.

Ce module prolonge le module 3 consacré aux services : une action utilisateur lente se lit souvent avec le service qu’elle appelle. Pour la mise en place, voir le RUM et les Core Web Vitals et le monitoring synthétique HTTP et navigateur.

Les métriques application builtin en un tableau

Toutes les clés, unités et agrégations ci-dessous proviennent de la liste officielle des métriques intégrées de Dynatrace Managed. La colonne « Portée » reprend l’étiquette de la documentation ([web], [mobile, custom], [browser monitor], [HTTP monitor]) ; les dimensions exactes se lisent dans le descripteur de chaque métrique. Une unité vide signifie un score sans unité.

Clé Unité Agrégations Portée Ce qu’elle mesure
builtin:apps.web.apdex.userType (score) avg Web Apdex des actions utilisateur, par type d’utilisateur
builtin:apps.web.actionCount.load.browser Count value Web Nombre d’actions de chargement, par navigateur
builtin:apps.web.actionDuration.load.browser Millisecond avg, count, max, median, min, percentile, sum Web Durée des actions de chargement
builtin:apps.web.actionDuration.xhr.browser Millisecond avg, count, max, median, min, percentile, sum Web Durée des actions XHR
builtin:apps.web.visuallyComplete.load.browser Millisecond avg, count, max, median, min, percentile, sum Web Temps de rendu complet de la zone visible
builtin:apps.web.largestContentfulPaint.load.browser Millisecond avg, count, max, median, min, percentile, sum Web Largest Contentful Paint (LCP)
builtin:apps.web.cumulativeLayoutShift.load.browser (score) avg, count, max, median, min, percentile, sum Web Cumulative Layout Shift (CLS)
builtin:apps.web.interactionToNextPaint Millisecond count, max, median, min, percentile Web Interaction to Next Paint (INP)
builtin:apps.web.activeSessions Count value Web Sessions actives estimées
builtin:apps.web.bouncedSessionRatio Percent (%) value Web Taux de rebond
builtin:apps.web.countOfErrors Count value Web Erreurs détectées, par type et origine
builtin:apps.web.jsErrorsDuringUa Count value Web Erreurs JavaScript pendant une action utilisateur
builtin:apps.web.percentageOfUserActionsAffectedByErrors Percent (%) value Web % d’actions utilisateur touchées par une erreur
builtin:apps.other.apdex.osAndVersion (score) value Mobile, custom Apdex par OS et version de l’app
builtin:apps.other.uaDuration.osAndVersion Microsecond avg, count, max, median, min, percentile, sum Mobile, custom Durée des actions utilisateur
builtin:apps.other.crashCount.osAndVersion Count value Mobile, custom Crashs détectés, par OS et version
builtin:apps.other.crashFreeUsersRate.os Percent (%) value Mobile, custom % estimé d’utilisateurs sans crash
builtin:synthetic.browser.availability.location.total Percent (%) avg Moniteur navigateur Taux de disponibilité, par emplacement
builtin:synthetic.browser.failure Count value Moniteur navigateur Exécutions en échec
builtin:synthetic.browser.totalDuration Millisecond avg, count, max, median, min, percentile, sum Moniteur navigateur Durée totale des actions d’une exécution
builtin:synthetic.http.availability.location.total Percent (%) avg Moniteur HTTP Taux de disponibilité, par emplacement
builtin:synthetic.http.duration.geo Millisecond avg, count, max, min, sum Moniteur HTTP Durée cumulée des requêtes, par emplacement
builtin:synthetic.http.statusCode Count value Moniteur HTTP Exécutions par code de statut HTTP

{{img:141-metriques-application-builtin-1.png|Extrait de la documentation Dynatrace Managed : clés builtin:apps.web, apps.other et synthetic avec leur nom, leur unité et leurs agrégations}}

Comment lire une fiche

Chaque fiche suit le même ordre : ce que mesure la métrique, un cas d’usage concret, un piège, puis un selector. Les selectors découpent par dt.entity.application pour le web, dt.entity.synthetic_test pour les moniteurs navigateur et dt.entity.http_check pour les moniteurs HTTP, avec seulement les transformations documentées (splitBy, sort, limit, agrégations, percentile). Les seuils évoqués sont des repères à calibrer sur votre historique, pas des valeurs officielles, sauf mention explicite.

Applications web : expérience et performance

builtin:apps.web.apdex.userType

Score Apdex de 0 à 1 calculé sur les actions utilisateur, découpable par type d’utilisateur (réel, synthétique, robot). C’est l’indicateur de synthèse de l’expérience : il combine satisfaits, tolérants et frustrés selon les seuils configurés dans l’application. Cas d’usage : un SLO « Apdex des utilisateurs réels » par application. Piège : sans filtrer le type d’utilisateur, les robots et le synthétique se mélangent au trafic réel.

builtin:apps.web.apdex.userType:splitBy("dt.entity.application"):avg:sort(value(avg,ascending)):limit(10)

builtin:apps.web.actionCount.load.browser

Nombre d’actions de chargement de page, découpé par navigateur. C’est le trafic vu du client, la contrepartie du débit des services. Cas d’usage : une chute brutale alors que les services répondent normalement signale souvent un problème de CDN, de DNS ou d’injection du JavaScript RUM. Piège : les actions XHR et custom ont leurs propres clés ; une application monopage génère peu de « load ».

builtin:apps.web.actionCount.load.browser:splitBy("dt.entity.application"):sum

builtin:apps.web.actionDuration.load.browser

Durée des actions de chargement, du clic à la fin du chargement. Cas d’usage : suivre le 90e percentile par application plutôt que la moyenne, qui masque la queue lente. Piège : cette durée inclut le réseau du client et le rendu ; une hausse ne vient pas forcément du back-end.

builtin:apps.web.actionDuration.load.browser:splitBy("dt.entity.application"):percentile(90)

builtin:apps.web.actionDuration.xhr.browser

Durée des actions XHR, c’est-à-dire les appels asynchrones déclenchés par un clic dans une page déjà chargée. Pour une application monopage, c’est souvent la métrique de performance principale. Cas d’usage : corréler une hausse avec le temps de réponse du service appelé (module 3). Piège : des appels de fond mal regroupés peuvent gonfler ou fausser la mesure.

builtin:apps.web.actionDuration.xhr.browser:splitBy("dt.entity.application"):percentile(90)

builtin:apps.web.visuallyComplete.load.browser

Temps nécessaire pour que le contenu de la zone visible soit entièrement rendu. Métrique propre à Dynatrace, elle colle à la perception « la page est prête ». Cas d’usage : comparer avant et après un déploiement front-end. Piège : un carrousel ou une animation sans fin peuvent retarder la valeur sans gêner l’utilisateur.

builtin:apps.web.visuallyComplete.load.browser:splitBy("dt.entity.application"):median

builtin:apps.web.largestContentfulPaint.load.browser

Temps de rendu du plus grand élément de la zone visible, l’un des Core Web Vitals. Google qualifie de « bon » un LCP inférieur ou égal à 2,5 s au 75e percentile ; ce repère vient de web.dev, pas de Dynatrace. Cas d’usage : suivre le LCP des pages d’atterrissage, sensibles au référencement. Piège : calculé seulement pour les actions de chargement et les navigateurs qui exposent l’API.

builtin:apps.web.largestContentfulPaint.load.browser:splitBy("dt.entity.application"):percentile(75)

builtin:apps.web.cumulativeLayoutShift.load.browser

Score sans unité des déplacements inattendus d’éléments visibles pendant le chargement. Cas d’usage : détecter une bannière ou une publicité insérée sans réserver sa place, qui fait cliquer au mauvais endroit. Piège : c’est un score, pas une durée ; ne le mettez pas sur le même axe que les métriques en millisecondes.

builtin:apps.web.cumulativeLayoutShift.load.browser:splitBy("dt.entity.application"):percentile(75)

builtin:apps.web.interactionToNextPaint

Interaction to Next Paint : délai entre une interaction (clic, saisie) et l’affichage suivant. Le Core Web Vital de réactivité qui remplace le First Input Delay. Cas d’usage : repérer un JavaScript trop lourd qui fige l’interface. Piège : la documentation ne liste pas l’agrégation avg pour cette clé ; utilisez médiane ou percentile.

builtin:apps.web.interactionToNextPaint:splitBy("dt.entity.application"):percentile(75)

builtin:apps.web.activeSessions

Nombre estimé de sessions actives, c’est-à-dire où l’utilisateur est confirmé encore présent. La documentation précise que l’estimation repose sur l’algorithme HyperLogLog. Cas d’usage : savoir combien d’utilisateurs un incident touche en ce moment, chiffre attendu dans toute communication d’incident. Piège : valeur approchée ; ne la réconciliez pas au chiffre près avec un outil marketing.

builtin:apps.web.activeSessions:splitBy("dt.entity.application"):max

builtin:apps.web.bouncedSessionRatio

Pourcentage de sessions limitées à une seule page et une seule requête web. Cas d’usage : une hausse brusque après une mise en production peut révéler une page d’accueil cassée que les métriques techniques ne voient pas. Piège : le rebond dépend beaucoup du type de page ; une page d’information a naturellement un taux élevé.

builtin:apps.web.bouncedSessionRatio:splitBy("dt.entity.application"):avg

builtin:apps.web.countOfErrors

Nombre d’erreurs détectées, découpable par type d’utilisateur, type d’erreur et origine. Cas d’usage : séparer les erreurs JavaScript des erreurs de requête pour savoir quelle équipe appeler. Piège : un script tiers bruyant (publicité, chat) peut dominer le compteur ; filtrez l’origine avant d’alerter.

builtin:apps.web.countOfErrors:splitBy("dt.entity.application"):sum:sort(value(sum,descending)):limit(10)

builtin:apps.web.jsErrorsDuringUa

Erreurs JavaScript survenues pendant une action utilisateur. Sa jumelle builtin:apps.web.jsErrorsWithoutUa compte celles survenues entre deux actions. Cas d’usage : les erreurs pendant une action touchent directement un clic, elles sont plus urgentes. Piège : un compteur brut grandit avec le trafic ; rapportez-le au nombre d’actions.

builtin:apps.web.jsErrorsDuringUa:splitBy("dt.entity.application"):sum

builtin:apps.web.percentageOfUserActionsAffectedByErrors

Pourcentage d’actions utilisateur avec au moins une erreur détectée. Déjà normalisée par le trafic, elle fait un bon SLI d’erreur côté client. Cas d’usage : un SLO « moins de X % d’actions en erreur », X fixé à partir de votre historique. Piège : une erreur sans impact visible compte autant qu’une page blanche.

builtin:apps.web.percentageOfUserActionsAffectedByErrors:splitBy("dt.entity.application"):avg

Applications mobiles et custom

builtin:apps.other.apdex.osAndVersion

Apdex des actions utilisateur d’une application mobile ou custom, par OS et version de l’application. Cas d’usage : vérifier qu’une nouvelle version publiée sur les stores ne dégrade pas l’expérience avant d’élargir le déploiement progressif. Piège : les anciennes versions gardent peu d’utilisateurs ; leur Apdex varie fortement sur un petit échantillon.

builtin:apps.other.apdex.osAndVersion:splitBy():avg

builtin:apps.other.uaDuration.osAndVersion

Durée des actions utilisateur mobiles, par OS et version. Cas d’usage : comparer le 90e percentile entre deux versions de l’app. Piège : l’unité est la microseconde, pas la milliseconde comme pour le web ; vérifiez l’axe avant de conclure à une régression.

builtin:apps.other.uaDuration.osAndVersion:splitBy():percentile(90)

builtin:apps.other.crashCount.osAndVersion

Nombre de crashs détectés, par OS et version. Cas d’usage : une version qui concentre les crashs juste après sa publication justifie un gel du déploiement. Piège : un compteur absolu suit le nombre d’utilisateurs ; préférez le taux d’utilisateurs sans crash pour comparer.

builtin:apps.other.crashCount.osAndVersion:splitBy():sum

builtin:apps.other.crashFreeUsersRate.os

Pourcentage estimé d’utilisateurs uniques non touchés par un crash, par OS (estimation HyperLogLog selon la documentation). C’est le SLI de stabilité mobile le plus lisible pour une équipe produit. Cas d’usage : suivre un objectif de stabilité par plateforme iOS et Android. Piège : valeur estimée, peu fiable sur une application à très faible audience.

builtin:apps.other.crashFreeUsersRate.os:splitBy():avg

Moniteurs synthétiques navigateur et HTTP

builtin:synthetic.browser.availability.location.total

Taux de disponibilité des moniteurs navigateur, par emplacement. Cas d’usage : SLI de disponibilité d’un parcours critique (connexion, paiement), mesuré même sans trafic réel. La variante …totalWoMaintenanceWindow exclut les fenêtres de maintenance, utile pour un rapport de SLA. Piège : un seul emplacement en échec fait baisser la moyenne ; regardez le découpage par lieu avant d’escalader.

builtin:synthetic.browser.availability.location.total:splitBy("dt.entity.synthetic_test"):avg

builtin:synthetic.browser.failure

Nombre d’exécutions en échec d’un moniteur navigateur. Rapporté à builtin:synthetic.browser.total, il donne un taux d’échec. Cas d’usage : alerter sur plusieurs échecs consécutifs plutôt que sur un seul, souvent dû à un aléa réseau de l’emplacement. Piège : un script cassé par un changement d’interface échoue aussi ; vérifiez le détail avant d’accuser la production.

builtin:synthetic.browser.failure:splitBy("dt.entity.synthetic_test"):sum

builtin:synthetic.browser.totalDuration

Durée de toutes les actions d’une exécution, par moniteur. Cas d’usage : une ligne de base stable, sans la variabilité des réseaux clients, pour détecter une régression de performance au déploiement. Piège : ajouter une étape au script allonge la durée ; annotez ces changements sur vos graphiques.

builtin:synthetic.browser.totalDuration:splitBy("dt.entity.synthetic_test"):avg

builtin:synthetic.http.availability.location.total

Taux de disponibilité des moniteurs HTTP, par emplacement. Plus légers que les moniteurs navigateur, ils surveillent API et points de santé à haute fréquence. Cas d’usage : SLI de disponibilité d’une API publique. Piège : un moniteur HTTP valide une réponse, pas le rendu d’une page ; il ne remplace pas un moniteur navigateur pour un parcours.

builtin:synthetic.http.availability.location.total:splitBy("dt.entity.http_check"):avg

builtin:synthetic.http.duration.geo

Durée cumulée de toutes les requêtes d’un moniteur HTTP, par emplacement. Les clés voisines …dns.geo, …tcpConnectTime.geo, …tlsHandshakeTime.geo et …timeToFirstByte.geo décomposent ce temps. Cas d’usage : une hausse limitée à un seul emplacement oriente vers le réseau plutôt que l’application. Piège : pas de médiane ni de percentile documentés pour cette clé.

builtin:synthetic.http.duration.geo:splitBy("dt.entity.http_check"):max

builtin:synthetic.http.statusCode

Nombre d’exécutions par code de statut HTTP, par emplacement. Cas d’usage : distinguer un 503 (service indisponible) d’un 401 (jeton expiré dans le moniteur), deux incidents très différents. Piège : un 200 ne garantit pas un contenu correct ; ajoutez une règle de validation dans le moniteur.

builtin:synthetic.http.statusCode:splitBy("dt.entity.http_check"):sum

Comment vérifier que ça fonctionne

  1. Ouvrez le Data Explorer, passez en mode Code et collez un selector d’une fiche : un graphique doit s’afficher en quelques secondes.
  2. Si la réponse est vide, lisez le descripteur : GET /api/v2/metrics/builtin:apps.web.apdex.userType avec un jeton portant le scope metrics.read. Il liste unité, agrégations et dimensions.
  3. Pour le RUM web, vérifiez que l’application est bien détectée et que le JavaScript RUM est injecté dans les pages (onglet réseau du navigateur).
  4. Pour le synthétique, vérifiez que le moniteur est actif et qu’un emplacement (public ou privé, ActiveGate synthétique) lui est assigné.
curl -s -H "Authorization: Api-Token $DT_TOKEN" \
  "https://managed.example.com/e/ENV-ID/api/v2/metrics/query?metricSelector=builtin:synthetic.http.availability.location.total:avg&from=now-24h"

Bonnes pratiques

  • Combinez RUM et synthétique : le RUM dit ce que vivent les utilisateurs, le synthétique dit si le service répond quand personne ne l’utilise.
  • Percentiles plutôt que moyennes pour les durées : la moyenne cache les utilisateurs les plus lents.
  • Filtrez les robots et le synthétique des SLO d’expérience réelle grâce au type d’utilisateur.

Questions fréquentes

Pourquoi les clés mobiles commencent-elles par apps.other ?

Dans Dynatrace Managed, les applications mobiles et custom partagent la famille builtin:apps.other.*, étiquetée [mobile, custom] dans la documentation. Seules quelques clés, comme builtin:apps.mobile.sessionCount, portent un préfixe dédié.

Les Core Web Vitals de Dynatrace sont-ils les mêmes que ceux de Google ?

Ils mesurent les mêmes phénomènes (LCP, CLS, INP) chez vos vrais utilisateurs, mais sur votre population et vos navigateurs. Les chiffres peuvent donc différer des rapports de Google, qui s’appuient sur un autre échantillon.

Ces clés fonctionnent-elles sur Dynatrace SaaS ?

Dans l’interface classique de SaaS, oui. Sur Grail, le RUM et le synthétique exposent d’autres clés interrogées en DQL ; le parcours métriques SaaS les détaille.

Avec ces 23 fiches, vous disposez des SLI côté utilisateur : expérience, réactivité, erreurs, stabilité mobile et disponibilité synthétique. Le module suivant redescend vers les processus, les runtimes et les conteneurs.

← Module 3 : services · Sommaire du parcours · Module 5 : processus et conteneurs →

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Ce module est une sélection commentée : la référence reste la documentation officielle de votre version de Dynatrace Managed, où chaque clé, unité et agrégation doit être vérifiée.

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 — Services : 20 métriques service builtin de Dynatrace Managed

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

Next Post
Module 5 — Processus et conteneurs : les métriques processus builtin, runtimes et Kubernetes

Module 5 — Processus et conteneurs : les métriques processus builtin, runtimes et Kubernetes

Related Posts