Requête XHR : comprendre, écrire et superviser XMLHttpRequest

Requête XHR en JavaScript : créer, envoyer et déboguer une XMLHttpRequest, gérer statut HTTP, réseau et CORS, puis la suivre avec le RUM de Dynatrace.
Requête XHR : comprendre, écrire et superviser XMLHttpRequest

Une requête XHR est une requête HTTP envoyée depuis le navigateur par l’objet JavaScript XMLHttpRequest. Elle permet d’échanger des données avec un serveur sans recharger la page. Selon MDN, l’API sert à envoyer des requêtes HTTP entre une page web et un serveur, et malgré son nom elle ne se limite pas au format XML.

Dans cet article, vous allez écrire une requête XHR pas à pas, traiter la réponse et les erreurs, comprendre les blocages CORS, puis voir comment le Real User Monitoring (RUM) mesure ces requêtes chez de vrais utilisateurs. La partie Dynatrace vaut pour Dynatrace SaaS comme pour Dynatrace Managed : la notion d’action XHR est la même dans le RUM classique des deux plateformes.

En bref

  • XHR est l’API historique d’AJAX : on crée l’objet, on pose des écouteurs, on appelle open, puis send.
  • Fetch est aujourd’hui recommandé quand c’est possible, mais XHR reste très présent dans les bases de code existantes et dans de nombreuses bibliothèques.
  • Les erreurs viennent surtout de trois sources : le statut HTTP, le réseau et CORS. Chacune se diagnostique différemment.
  • Le Real User Monitoring mesure la durée et les échecs de ces requêtes côté navigateur, sur de vrais parcours, ce que les tests en laboratoire ne montrent pas.

Ce qu’est une requête XHR, concrètement

Quand vous cliquez sur « Charger plus » et que de nouveaux éléments apparaissent sans changement d’URL, il y a de fortes chances qu’une requête XHR (ou son équivalent Fetch) ait été envoyée en arrière-plan. Le principe, que MDN décrit dans son guide sur la récupération de données du serveur, sépare deux tâches : JavaScript demande les données au serveur, puis manipule le DOM pour mettre à jour l’interface, au lieu de déclencher une navigation complète.

L’acronyme AJAX (Asynchronous JavaScript and XML) date d’une époque où XML était le format d’échange courant. Aujourd’hui, le serveur renvoie le plus souvent du JSON, parfois du HTML ou du texte, comme le rappelle la même page MDN. Un cours de l’université de Caen Normandie insiste sur deux points : la réponse n’est pas forcément du XML, et l’écouteur doit être ajouté avant de lancer la requête avec send.

Le mot « asynchrone » est central. Le navigateur n’attend pas la réponse pour continuer à afficher la page et à réagir aux clics. Vous décrivez ce qui doit se passer à l’arrivée de la réponse, et le code continue.

Écrire une requête XHR pas à pas

Selon MDN, une requête suit trois étapes : créer l’objet, ouvrir l’URL avec open, puis envoyer avec send. L’argument async de open vaut true par défaut ou lorsqu’il est omis : la requête est alors asynchrone. Voici un exemple minimal qui récupère du JSON.

Code JavaScript d'une requête XHR GET : écouteurs load, error et abort, puis open, setRequestHeader et send
Source : developer.mozilla.org
const xhr = new XMLHttpRequest();

xhr.addEventListener("load", () => {
  if (xhr.status >= 200 && xhr.status < 300) {
    const data = JSON.parse(xhr.responseText);
    console.log(data);
  } else {
    console.error("Statut HTTP inattendu :", xhr.status);
  }
});

xhr.addEventListener("error", () => console.error("Échec réseau"));
xhr.addEventListener("abort", () => console.warn("Requête annulée"));

xhr.open("GET", "https://api.exemple.fr/produits");
xhr.setRequestHeader("Accept", "application/json");
xhr.send();

Les quatre étapes à retenir

  1. Instancier l’objet avec new XMLHttpRequest().
  2. Brancher les écouteurs d’événements. MDN précise qu’ils doivent être ajoutés avant l’appel à open, sinon les événements progress ne sont pas captés.
  3. Ouvrir la requête avec open(méthode, url). Les en-têtes se définissent après open et avant send.
  4. Envoyer avec send(). D’après la page XMLHttpRequest.send(), cette méthode envoie la requête au serveur et accepte un paramètre facultatif pour le corps, utilisé surtout pour des requêtes comme PUT. Pour GET ou HEAD, ce corps est ignoré.

Envoyer des données avec POST

Pour un POST en JSON, ouvrez la requête avec la méthode POST, déclarez le type de contenu, puis passez le corps à send. L’exemple ci-dessous ajoute aussi un délai d’attente, détaillé plus loin :

Code JavaScript d'une requête XHR POST en JSON avec timeout de 8000 ms, en-tête Content-Type et corps JSON.stringify
Source : developer.mozilla.org
const xhr = new XMLHttpRequest();

xhr.timeout = 8000;
xhr.addEventListener("timeout", () => console.warn("Délai dépassé"));
xhr.addEventListener("load", () => console.log(xhr.status));

xhr.open("POST", "/api/commandes");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(JSON.stringify({ produit: 42, quantite: 2 }));

Choisir le type de réponse

La propriété responseType indique le format attendu : text (valeur par défaut), arraybuffer, blob, document ou json. Pour une API JSON, définir xhr.responseType = "json" avant l’envoi évite le JSON.parse manuel : le résultat se lit alors dans xhr.response, qui vaut null si le serveur renvoie autre chose que du JSON valide. Pour télécharger un fichier, blob est le choix habituel.

Suivre le déroulement : événements, statut et erreurs

Une requête XHR passe par plusieurs états, et la propriété readyState en donne la valeur. L’exemple historique de MDN teste readyState === XMLHttpRequest.DONE (la valeur 4) et status === 200 avant de lire la réponse. Les événements modernes sont plus lisibles que l’ancien onreadystatechange.

Tableau des événements XMLHttpRequest : progress, load, error, abort, timeout et loadend, avec le moment du déclenchement et l'usage typique
Source : developer.mozilla.org
Événement Quand il se déclenche Usage typique
progress Pendant le transfert Barre de progression d’un téléchargement
load Transfert terminé Lire la réponse et le statut
error Échec de la requête (réseau, CORS) Message d’erreur, nouvelle tentative
abort Requête annulée Nettoyer l’interface
timeout Délai xhr.timeout dépassé Informer l’utilisateur
loadend Fin, quel que soit le résultat Masquer un indicateur de chargement

Ce tableau reprend les définitions de la documentation MDN. Un point piège : load se déclenche aussi pour une réponse 404 ou 500, car le transfert a bien abouti. Testez donc toujours xhr.status dans le gestionnaire load, comme dans l’exemple plus haut. L’événement error, lui, signale que la requête n’a pas pu aboutir du tout.

Gérer le délai d’attente

Par défaut, xhr.timeout vaut 0, c’est-à-dire aucun délai : une requête peut rester en attente longtemps. Définissez xhr.timeout en millisecondes et écoutez l’événement timeout pour informer l’utilisateur, plutôt que de laisser un indicateur tourner indéfiniment. Cette valeur est aussi un bon point de départ pour décider ce qui est « trop lent » dans votre supervision.

Pourquoi une requête XHR échoue : HTTP, réseau et CORS

Trois familles de problèmes reviennent sans cesse. Les distinguer fait gagner beaucoup de temps.

Erreurs HTTP (4xx et 5xx)

Le serveur a répondu, mais avec un statut d’échec. La requête est « réussie » côté transfert, l’événement load se déclenche, et c’est à votre code de lire xhr.status. Un 401 ou 403 pointe vers l’authentification, un 404 vers une URL erronée, un 500 vers un problème côté serveur.

Erreurs réseau

Pas de réponse exploitable : connexion coupée, DNS introuvable, certificat invalide. Seul l’événement error se déclenche, sans statut utile. Dans le navigateur, le détail reste volontairement vague, et l’onglet Réseau des outils de développement est votre meilleur allié.

Erreurs CORS

Le navigateur applique la politique de même origine. Une requête vers un autre domaine n’aboutit que si le serveur l’autorise. MDN indique que XMLHttpRequest fonctionne tant que le serveur est configuré pour accepter l’origine de votre application web, via l’en-tête de réponse Access-Control-Allow-Origin. Côté code, le symptôme ressemble à une erreur réseau, mais la console du navigateur indique une raison CORS précise.

Deux cas fréquents :

  • Les cookies ne partent pas. Par défaut, les justificatifs (cookies, en-têtes d’authentification) ne sont pas envoyés dans une requête inter-origines. Le client doit définir xhr.withCredentials à true, et le serveur doit répondre avec l’en-tête Access-Control-Allow-Credentials: true, sinon le navigateur signale une erreur réseau.
  • Le test se fait depuis un fichier local. Les requêtes CORS ne peuvent utiliser que les schémas HTTP ou HTTPS. D’après MDN, une page ouverte en file:/// a une origine opaque et provoque une erreur CORS dans Firefox comme dans Chrome. Lancez un petit serveur local à la place.

La correction d’un blocage CORS se fait presque toujours côté serveur, en configurant les en-têtes de réponse. Aucun code JavaScript côté client ne peut contourner proprement cette règle.

XHR ou Fetch : que choisir aujourd’hui ?

Pour un nouveau code, MDN conseille Fetch lorsque c’est possible, car l’API est plus simple et offre davantage de fonctionnalités. XHR reste fréquent dans les bases de code historiques : c’est l’API qui a précédé Fetch et la première à permettre AJAX (source MDN).

En pratique, vous croiserez XHR dans trois situations :

  • une application ancienne à maintenir, où réécrire chaque appel n’est pas prioritaire ;
  • une bibliothèque tierce qui utilise XHR en interne ;
  • un besoin de suivi de progression d’envoi de fichier, où l’événement progress de XHR reste pratique.

Pour la supervision, la bonne nouvelle est que le choix ne change pas l’essentiel : le RUM de Dynatrace capture les appels XMLHttpRequest comme les appels fetch(), et vous pouvez migrer progressivement sans perdre la visibilité sur vos appels.

Accessibilité : ne pas oublier ce qui change dans la page

Une mise à jour de contenu asynchrone est invisible pour une personne qui utilise un navigateur vocal si rien ne l’annonce. La norme WAI-ARIA fournit des spécifications pour limiter ce type de problème, comme le rappelle la page Wikipédia consacrée à XMLHttpRequest. Concrètement, signalez les changements importants avec une région aria-live et gérez le focus après un chargement partiel.

Superviser les requêtes XHR avec le Real User Monitoring

Votre code fonctionne sur votre machine, avec une bonne connexion. Mais vos utilisateurs ont des réseaux mobiles, des extensions de navigateur, des appareils anciens. Le Real User Monitoring collecte des mesures directement dans leur navigateur pour répondre à une question simple : que vivent réellement les utilisateurs ?

RUM et données de terrain

Google utilise les données RUM de terrain pour déterminer si un site respecte les seuils recommandés pour les Core Web Vitals, comme l’explique web.dev. Le même article note que les données RUM que vous collectez vous-même complètent les outils fondés sur CrUX, avec des retours plus détaillés et plus immédiats.

Ce que Dynatrace fait des requêtes XHR

Dans Dynatrace, une interaction utilisateur qui déclenche des XMLHttpRequest ou des appels fetch() crée une action XHR. La page « User actions » de la documentation Dynatrace précise que l’action commence au clic de l’utilisateur, que Dynatrace détecte aussi les XHR supplémentaires déclenchées dans le callback de la première, et qu’il attend la fin de toutes les requêtes avant de clore l’action. Une action web dure au maximum 3 minutes. Pour une application monopage, où presque toute la communication passe par XHR après le premier chargement, c’est ce qui rend les parcours mesurables.

Deux réglages à connaître dans la configuration de l’application web (RUM classique, SaaS et Managed) : la capture des XHR s’active dans Capturing > Async web requests and SPAs > Generic support, option « Capture XmlHttpRequest (XHR) », et des règles d’exclusion par expression régulière sur l’URL écartent les appels techniques (heartbeat, télémétrie) qui créeraient des actions parasites. Autre point documenté : la requête doit démarrer dans les 30 ms qui suivent l’interaction ; du code fondé sur des promesses peut dépasser cette fenêtre, et Dynatrace recommande alors l’API JavaScript RUM pour créer l’action soi-même.

Ce que vous pouvez lire ensuite dépend de votre configuration, mais les questions à poser sont toujours les mêmes :

  1. Quelle action est la plus lente pour les utilisateurs, et sur quel navigateur ou quel type d’appareil ?
  2. Quel appel XHR cause les erreurs, avec quel code HTTP ?
  3. La lenteur vient-elle du réseau ou du serveur ? Rapprochez la durée côté navigateur de la trace côté serveur.
  4. Les erreurs JavaScript apparaissent-elles juste après une réponse inattendue ?

Pour la mise en place de l’injection JavaScript, le choix des applications et la lecture des Core Web Vitals, suivez notre guide sur la configuration du RUM dans Dynatrace. Une fois vos actions mesurées, notre module sur le metric selector et les alertes montre comment interroger ces métriques et déclencher une alerte quand une durée dépasse votre seuil.

Un exemple de démarche de diagnostic

Imaginons une page de recherche dont l’utilisateur se plaint qu’elle « rame ». Voici une démarche réaliste, sans chiffres inventés :

  1. Dans le RUM, filtrez sur l’action XHR déclenchée par la recherche et regardez la répartition des durées plutôt que la moyenne.
  2. Segmentez par navigateur, pays et type de connexion, pour voir si le problème est général ou localisé.
  3. Si la durée est longue partout, ouvrez la trace distribuée associée et cherchez le service ou la requête de base de données responsable.
  4. Si elle n’est longue que sur mobile, examinez la taille de la réponse : une API qui renvoie trop de champs coûte cher sur un réseau lent.
  5. Après correction, comparez avant et après sur une même période pour confirmer l’effet.

Pour des objectifs de latence fondés sur la distribution plutôt que sur la moyenne, voyez aussi nos métriques histogrammes OpenPipeline. Et pour reproduire un appel lent depuis un agent de code, Chrome DevTools MCP donne accès au panneau Réseau depuis l’assistant.

Bonnes pratiques pour des requêtes XHR fiables

  • Toujours tester status dans load, jamais seulement l’arrivée de l’événement.
  • Définir un timeout et un message clair pour l’utilisateur.
  • Annuler les requêtes devenues inutiles avec abort(), par exemple quand l’utilisateur tape une nouvelle recherche.
  • Éviter le mode synchrone : il bloque l’interface, et timeout comme responseType y sont interdits dans une page.
  • Préférer HTTPS et ne jamais placer de secret dans le code client.
  • Mesurer en production : un appel qui paraît rapide en développement peut être lent chez vos utilisateurs.

Notre point de vue

Chez span.observer, nous constatons que la plupart des questions sur les requêtes XHR cachent une question de supervision : la requête part, mais personne ne sait combien de temps elle prend chez l’utilisateur ni pourquoi elle échoue.

Nous croyons qu’un développeur progresse plus vite quand il relie trois niveaux : le code (ce guide), la mesure côté navigateur (le RUM) et la trace côté serveur. C’est pourquoi nos tutoriels Dynatrace partent de problèmes concrets de production, en Managed comme en SaaS, et restent gratuits, indépendants et sans publicité.

Notre approche est de vous donner des gestes immédiatement applicables : configurer, lire, interroger, alerter. Vous apprenez à votre rythme, et vous pouvez partager ces ressources avec votre équipe.

Aller plus loin avec nos ressources gratuites

Si vous voulez passer de la requête XHR isolée à une vision complète de vos applications, notre formation observabilité gratuite suit un chemin progressif, des signaux jusqu’aux SLO. Elle s’adresse aux développeurs, aux SRE et aux responsables IT qui veulent former leurs équipes.

Questions fréquentes

Qu’est-ce qu’une requête XHR ?

C’est une requête HTTP envoyée par l’objet JavaScript XMLHttpRequest depuis le navigateur. Elle récupère ou envoie des données à un serveur sans recharger la page. Le format échangé est le plus souvent du JSON, même si XML figure dans le nom.

XHR et Fetch, quelle différence ?

Les deux envoient des requêtes HTTP depuis le navigateur. MDN conseille Fetch quand c’est possible, car il est plus simple et plus riche en fonctionnalités. XHR reste utile pour maintenir du code existant, et le RUM de Dynatrace capture les deux mécanismes au même titre.

Pourquoi ma requête XHR est-elle bloquée par CORS ?

Le serveur de destination n’autorise pas l’origine de votre page. Il faut configurer ses en-têtes de réponse CORS, et ajouter withCredentials côté client si des cookies doivent être envoyés. Vérifiez aussi que vous ne testez pas depuis une page ouverte en file:///.

Que mesure le Real User Monitoring sur une requête XHR ?

Il mesure, dans le navigateur de vrais utilisateurs, la durée et le résultat des appels déclenchés par leurs actions. Dans Dynatrace, ces appels forment des actions XHR que vous pouvez filtrer par navigateur, localisation ou application. Notre guide RUM détaille la configuration.

Sources

span.observer est un blog indépendant, non affilié à Dynatrace LLC. Les noms de produits cités appartiennent à leurs propriétaires respectifs ; les exemples de code et les URL sont fictifs et donnés à titre pédagogique.

Total
0
Shares
Laisser un commentaire

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

Previous Post
OpenObserve, observabilité open source en Rust : logs, métriques, traces et RUM

OpenObserve, observabilité open source en Rust : logs, métriques, traces et RUM

Next Post
Lightpanda navigateur headless en Zig : agents IA, mémoire et supervision

Lightpanda navigateur headless en Zig : agents IA, mémoire et supervision

Related Posts