RUM Dynatrace : configurer le Real User Monitoring et lire les Core Web Vitals

RUM Dynatrace : injectez le JavaScript RUM, vérifiez la collecte puis lisez LCP, CLS et INP au 75e centile avec DQL pour fixer des SLO côté utilisateur.
RUM Dynatrace : configurer le Real User Monitoring et lire les Core Web Vitals

Les tableaux de bord serveur sont verts, les temps de réponse des services sont bons, et pourtant le support reçoit des plaintes : « le site rame ». Le serveur ne voit qu’une partie du trajet. Le RUM Dynatrace (Real User Monitoring) mesure ce qui se passe dans le navigateur de chaque utilisateur : chargement, rendu, interactions, erreurs JavaScript.

Pour un SRE, c’est la seule source qui dit si le SLO tient du point de vue de l’utilisateur. Les Core Web Vitals (LCP, CLS, INP) donnent un langage commun avec les équipes frontend et produit : trois chiffres, des seuils publics, et une lecture au 75e centile qui évite de piloter sur une moyenne trompeuse.

Objectif de ce tutoriel : activer le RUM sur une application web, vérifier que les données arrivent, puis lire les Core Web Vitals avec DQL. La configuration vaut pour Dynatrace SaaS et Dynatrace Managed ; les requêtes DQL sur user.events concernent la nouvelle expérience RUM sur Grail, disponible en SaaS.

Ce que mesurent les Core Web Vitals

Indicateur Ce qu’il mesure Champ dans user.events
LCP (Largest Contentful Paint) Le moment où le plus gros élément visible est affiché web_vitals.largest_contentful_paint
CLS (Cumulative Layout Shift) La stabilité visuelle : la page « saute »-t-elle pendant le chargement ? web_vitals.cumulative_layout_shift
INP (Interaction to Next Paint) La réactivité : délai entre un clic et la mise à jour de l’écran web_vitals.interaction_to_next_paint

Les seuils « bon / à améliorer / mauvais » sont publiés par le projet web.dev de Google ; ils évoluent, référez-vous à la page officielle plutôt qu’à un chiffre recopié.

Prérequis

  • Un environnement Dynatrace SaaS ou Managed, avec le droit de configurer les applications web.
  • Soit OneAgent installé sur les serveurs web ou applicatifs qui servent les pages HTML (injection automatique), soit un accès au code ou au gabarit HTML de l’application (insertion manuelle).
  • Pour les requêtes DQL : la nouvelle expérience RUM activée sur un environnement SaaS, et un accès à Notebooks.
  • Un accord de votre DPO sur la collecte : adresse IP, identification des utilisateurs, Session Replay.

Configurer le RUM Dynatrace pas à pas

Étape 1 : choisir le mode d’injection

Deux chemins mènent au même JavaScript de monitoring :

  • Injection automatique : OneAgent, présent sur le serveur web, insère la balise dans chaque page HTML servie. Rien à modifier dans le code ; c’est le chemin le plus rapide.
  • Insertion manuelle : vous ajoutez la balise dans le gabarit HTML. Indispensable quand le serveur n’est pas instrumenté : CDN, hébergement statique, SaaS tiers, application monopage servie depuis un bucket.

Étape 2 : déclarer l’application web

Créez l’application web dans les paramètres de Dynatrace et définissez les règles de détection (domaine ou motif d’URL) qui rattachent le trafic à cette application. Une application par produit visible des utilisateurs est un bon découpage ; évitez de tout regrouper dans l’application par défaut, sinon les Core Web Vitals de l’intranet se mélangent à ceux du site public.

Étape 3 : récupérer la balise pour une insertion manuelle

Si vous avez choisi l’insertion manuelle, récupérez la balise la plus récente par l’API (SaaS ; en Managed, l’URL suit le format https://<votre-domaine>/e/<env-id>) :

curl -s "$DT_URL/api/v2/rum/javaScriptTag/APPLICATION-0123456789ABCDEF?scriptExecutionAttribute=ASYNC" \
  -H "Authorization: Api-Token $DT_API_TOKEN"

La réponse est un texte <script ...> à placer le plus haut possible dans le <head>. Le paramètre scriptExecutionAttribute accepte ASYNC, DEFER ou NONE. Automatisez cet appel dans votre build : la balise référence un fichier de configuration qui évolue avec les réglages de l’application. Pour le scope exact du token, consultez la page de l’endpoint dans la documentation.

Étape 4 : adapter la Content Security Policy

Une CSP stricte bloque silencieusement le script ou l’envoi des données. Dans le cas le plus simple (injection automatique, endpoint de beacon par défaut, Session Replay désactivé), la règle de base suffit :

Content-Security-Policy: script-src 'self'; connect-src 'self';

Si le script est chargé depuis un CDN ou si les beacons partent vers un autre domaine, ajoutez ces origines à script-src et connect-src. Testez en préproduction avec la console du navigateur ouverte : une violation CSP y apparaît immédiatement.

Étape 5 : régler la confidentialité

Activez le masquage des adresses IP, respectez le signal « Do Not Track » si votre politique l’exige et n’identifiez les utilisateurs qu’avec un identifiant pseudonyme. Si vous activez Session Replay, choisissez un niveau de masquage qui cache les champs de saisie (voir Session Replay sur Grail).

Comment vérifier que ça fonctionne

Ouvrez la page dans un navigateur, puis l’onglet Réseau des outils de développement : vous devez voir le chargement du script Dynatrace, puis des requêtes de beacon après quelques interactions. Côté Dynatrace, les premières sessions apparaissent en quelques minutes.

En SaaS, avec la nouvelle expérience RUM, lisez le LCP au 75e centile par page dans un Notebook :

fetch user.events
| filter characteristics.has_page_summary
| filter isNotNull(web_vitals.largest_contentful_paint)
| summarize page_LCP = percentile(web_vitals.largest_contentful_paint, 75), by:{ page.name }
| sort page_LCP desc

Puis les trois indicateurs ensemble, par application :

fetch user.events, from:now()-24h
| filter characteristics.has_page_summary
| summarize {
    lcp_p75 = percentile(web_vitals.largest_contentful_paint, 75),
    cls_p75 = percentile(web_vitals.cumulative_layout_shift, 75),
    inp_p75 = percentile(web_vitals.interaction_to_next_paint, 75),
    pages = count()
  }, by:{ frontend.name }

Une colonne vide pour INP n’est pas forcément une erreur : l’indicateur n’existe que si l’utilisateur a interagi avec la page. En Managed (RUM classique), les Core Web Vitals se lisent dans l’analyse de l’application web et des actions utilisateur.

Bonnes pratiques

  • Pilotez au 75e centile, jamais à la moyenne : une moyenne masque les utilisateurs mobiles lents.
  • Découpez par page et par appareil : une régression du LCP touche souvent un seul gabarit.
  • Transformez un indicateur en SLO : par exemple « 90 % des pages de paiement avec un LCP bon » sur 28 jours, avec des alertes de burn rate plutôt qu’un seuil fixe.
  • Reliez le frontend au backend : une action lente se suit jusqu’aux spans du service appelé (voir OpenTelemetry de bout en bout).
  • Complétez par du synthétique pour les heures sans trafic, où le RUM n’a rien à mesurer.

Questions fréquentes

Le RUM ralentit-il les pages ?

Le script est chargé de manière asynchrone et envoie ses données par lots. Son coût est faible, mais mesurez-le : comparez le LCP avant et après activation sur une page de test, en préproduction.

Pourquoi aucune donnée n’arrive alors que la balise est présente ?

Les trois causes les plus fréquentes : une CSP qui bloque le script ou les beacons, une règle de détection qui rattache le trafic à une autre application, ou un bloqueur de publicité sur le poste de test. Vérifiez l’onglet Réseau, puis la console.

Faut-il activer Session Replay en même temps ?

Non, c’est un choix séparé. Commencez par le RUM seul, validez la confidentialité avec votre DPO, puis activez Session Replay sur un pourcentage réduit de sessions.

Conclusion

Le RUM Dynatrace se met en place en une heure : injection automatique ou balise manuelle, une CSP adaptée, des règles de confidentialité claires. Le vrai travail commence ensuite : lire LCP, CLS et INP au 75e centile, page par page, et en faire des SLO qui reflètent enfin ce que vivent les utilisateurs.

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, d’écrans et de réglages évoluent : vérifiez-les dans la documentation officielle de votre version.

Total
0
Shares
Laisser un commentaire

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

Previous Post
Monitoring synthétique Dynatrace : tutoriel HTTP et navigateur, API, coût et emplacements

Monitoring synthétique Dynatrace : tutoriel HTTP et navigateur, API, coût et emplacements

Next Post
DQL avancé : lookup, join, parse et fonctions de fenêtre

DQL avancé : lookup, join, parse et fonctions de fenêtre

Related Posts