Le En-tête « Server-Timing » transmet les indicateurs backend qu'il a lui-même collectés via une réponse HTTP. Vous pouvez les associer à la requête correspondante dans les DevTools du navigateur ou les récupérer via l'API de performance. Pour cela, il faut que l'application ou un autre composant répondant à la requête collecte et renvoie ces valeurs. L'en-tête n'est pas un outil de profilage automatique : seules des limites de mesure documentées permettent de déterminer la durée d'une opération. Les chevauchements, les chemins réseau et les réponses mises en cache peuvent modifier l'interprétation.
Ce que « Server Timing » permet de mettre en évidence
Une page lente peut subir des pertes de temps au niveau du navigateur, sur le réseau ou lors du traitement sur le serveur. Le En-tête « Server-Timing » combine ces deux approches : il transmet, avec une réponse HTTP, les indicateurs de performance enregistrés par un composant serveur concerné. Le navigateur peut ensuite les associer à la requête correspondante et les afficher.
Pour cela, l'application doit, par exemple, mesurer la durée d'une opération sur la base de données et inscrire cette valeur dans l'en-tête de réponse. Un proxy ou tout autre composant chargé de générer la réponse peut également fournir des métriques. Sans un tel outillage, le navigateur ne peut pas déterminer a posteriori combien de temps ont duré les différentes étapes du traitement côté serveur.
L'en-tête est donc un Format de transport, ce n'est pas un profileur automatique. Il ne détermine pas quelles fonctions internes doivent être analysées ni le niveau de détail avec lequel une application doit effectuer ses mesures. Les indicateurs affichés dépendent des données que le composant responsable collecte et autorise à afficher.
Pour les Performances du backend Cela s'avère utile, car un segment mesuré par vos soins s'affiche juste à côté des informations relatives à la requête du navigateur. Une valeur élevée constitue dans un premier temps un point de départ pour des analyses plus approfondies, mais ne prouve pas encore pourquoi une page est lente. À lui seul, cet indicateur n'explique ni la cause du problème, ni tous les autres facteurs influant sur les performances Web.
Pour une utilisation pratique, tu dois donc avoir accès à l'application ou à un autre composant susceptible d'influencer la réponse. En revanche, si des métriques sont déjà fournies, tu peux les examiner dans le navigateur sans avoir à modifier toi-même la configuration du serveur. Même dans ce cas, tu dois vérifier d'où proviennent ces valeurs et ce qu'elles englobent réellement.
Comprendre les métriques et la syntaxe des en-têtes
Une réponse HTTP peut contenir une ou plusieurs lignes d'en-tête « Server Timing ». Au sein d'une ligne, les virgules séparent les différentes métriques ; chaque paramètre est introduit par un point-virgule. Chaque métrique doit comporter un nom, tandis que la durée et la description sont facultatives. La durée indiquée figure dans le paramètre dur et s'exprime en millisecondes.
L'exemple suivant présente une ligne d'en-tête de réponse HTTP contenant deux métriques. Les chiffres sont choisis arbitrairement et ne correspondent à aucune mesure réelle ; cette ligne est simplement un exemple syntaxique et ne suppose aucune application ni configuration de serveur particulière.
Ici, on désigne db une métrique comprenant la durée et une description ; render a une durée, mais pas de description. Les informations selon desc ont pour but de fournir des explications. Elles ne remplacent pas les informations indiquant quand chaque mesure commence et se termine.
| composant | Signification | Statut obligatoire | Exemple |
|---|---|---|---|
| Nom | Désigne la métrique | Nécessaire | db |
| dur | Durée en millisecondes | En option | dur = 42,5 |
| desc | Description de l'indicateur | En option | desc="Base de données" |
Un nom comme db ne révèle pas en soi ni la Limites de mesure ni la méthode de mesure. Il pourrait désigner une requête isolée, plusieurs requêtes cumulées ou une partie de la base de données définie autrement. Seule la documentation de l'instrumentation permet de comprendre quel travail est réellement inclus dans la valeur.
Pour obtenir des comparaisons pertinentes, tu dois donc noter le point de départ et le point d'arrivée de chaque indicateur et préciser s'il inclut d'autres opérations partielles. Si, par exemple, le nom reste le même alors que l'application intègre par la suite des requêtes supplémentaires dans la période considérée, les anciennes et les nouvelles valeurs ne sont pas facilement comparables. La syntaxe à elle seule n’indique pas un tel changement.
Distinguer la durée du traitement côté serveur et le temps d'attente du navigateur
Le temps d'attente affiché dans le navigateur et la durée indiquée par le backend ne correspondent pas nécessairement au même intervalle de temps. Une métrique peut ne couvrir qu’une partie délibérément choisie du traitement, tandis que l’affichage du navigateur représente d’autres étapes du parcours de la requête et de la réponse. Des chiffres similaires ou différents ne signifient donc pas automatiquement que les deux mesures se confirment ou se contredisent.
Des chemins réseau et des proxys peuvent par exemple se trouver entre le navigateur et l'application. De même, les files d'attente ou les étapes de traitement au sein du backend peuvent ne pas être prises en compte dans les points de mesure définis. Si le navigateur attend plus longtemps que la durée indiquée pour une opération de base de données, il n'est donc pas possible d'attribuer la différence à une cause spécifique en se basant uniquement sur cet indicateur.
À l'inverse, les indicateurs de synchronisation du serveur peuvent se chevaucher ou être imbriquées les unes dans les autres. Si une métrique globale mesure le traitement d'une requête, y compris l'opération sur la base de données, la durée de cette dernière est déjà incluse dans la valeur globale. Si tu additionnes les deux chiffres, tu comptes cette partie deux fois ; dans le cas d'opérations exécutées en parallèle, la somme de leurs durées individuelles peut également être supérieure au temps écoulé.
L'en-tête ne constitue donc pas automatiquement un Chute d'eau du traitement. Il fournit des indicateurs spécifiques, mais les noms et les durées ne permettent à eux seuls ni d'établir un ordre chronologique ni de définir des relations entre les différentes étapes. Pour l'interpréter, tu dois savoir si l'instrumentation enregistre des tâches distinctes, imbriquées ou s'exécutant simultanément.
Avant de tirer des conclusions quant à une optimisation, définis les limites de mesure et les conditions de la requête considérée. Répète ensuite des requêtes similaires et vérifie si le schéma se reproduit dans les mêmes conditions. Tu pourras ainsi mieux distinguer une valeur isolée inhabituelle d'un indice récurrent, sans pour autant attribuer une cause à l'indicateur seul.
Vérifier la réponse HTML dans DevTools
Pour une page HTML dynamique, l'application peut enregistrer deux étapes distinctes : une opération sur la base de données, puis la génération du code HTML. La mesure doit être configurée dans l'application ou dans un autre composant qui renvoie une réponse. DevTools affiche les valeurs fournies, mais ne calcule pas lui-même les durées d'exécution internes.
Définis pour db le début, juste avant l'appel d'une opération de base de données donnée, et la fin, dès que son résultat est disponible dans l'application. Pour render Cette période commence juste avant la génération du code HTML et se termine dès que le code HTML finalisé est prêt à être renvoyé. Précisez si, par exemple, le chargement des modèles est inclus dans cette période.
Supposons que ces deux étapes soient terminées avant l'envoi des en-têtes de réponse : dans ce cas, la réponse pourrait Server-Timing: db;dur=42.5, render;dur=18.0 sont indiqués. Ces chiffres sont choisis arbitrairement et ne constituent pas une mesure. Seuls les points de départ et d'arrivée documentés permettent de les comparer de manière pertinente dans le cadre d'une analyse ultérieure.
Dans Chrome, ouvre les outils de développement et l'onglet « Réseau ». Actualise la page, sélectionne la requête de document dans la liste des requêtes et vérifie, sous « En-têtes », l'en-tête brut reçu. Sous « Timing », tu peux ensuite consulter l'affichage des valeurs de synchronisation du serveur signalées ; la présentation exacte peut varier selon le navigateur.
Un modèle qui ne passe pas inaperçu Valeur individuelle Il s'agit d'un point de départ, et non d'une preuve d'une cause générale. Répétez des requêtes similaires et notez notamment la page utilisée, l'état du cache et les modifications apportées à l'application. Vous pourrez ainsi mieux déterminer si une tendance se répète ou si une réponse isolée sort du cadre habituel.
Lire les temps API sans double comptage
Dans le cas d'une API, l'application peut gérer non seulement l'ensemble du traitement, mais aussi l'attente d'un service externe. Ce qui est déterminant ici, c'est la Limite de mesure: Si le temps total commence à l'entrée dans le gestionnaire API et se termine lorsque sa réponse est prête à être affichée, l'appel externe peut être entièrement inclus dans ce délai.
Dans l'exemple suivant, choisi à titre indicatif, la durée externe commence juste avant l'envoi de la requête au service et se termine dès que la réponse de celui-ci est disponible dans l'application. Les valeurs sont données à titre indicatif uniquement et ne constituent pas une mesure. Le tableau décrit expressément des durées imbriquées, et non deux lots de travail indépendants.
| Métriques | Limites de mesure dans l'exemple | Durée |
|---|---|---|
| Traitement global | Entrée dans le gestionnaire jusqu’à ce que la réponse soit disponible | 120 ms |
| Appel externe | Envoi de la demande jusqu'à réception de la réponse du service | 80 ms |
Le calcul 120 ms plus 80 ms donne certes 200 ms, mais ce serait ici une Double comptage: Ces 80 ms sont déjà comprises dans les 120 ms. Mathématiquement, il reste donc 40 ms de la durée totale en dehors de l'appel externe. L'en-tête ne permet toutefois pas à lui seul d'expliquer quelle tâche ou quel temps d'attente cette durée restante recouvre.
De même, les dépendances parallèles ne peuvent pas être simplement additionnées pour obtenir un temps total écoulé. Si, par exemple, deux appels s'exécutent simultanément et durent chacun 80 ms, leurs durées individuelles s'additionnent pour donner 160 ms, bien que leurs durées puissent se chevaucher en grande partie. Sans information sur le début et la fin, le degré réel de chevauchement ne peut être déterminé à partir des durées seules.
Pour déterminer quel service a déclenché quel appel suivant, le traçage distribué complète les valeurs d'en-tête. Le « Server Timing » permet d'associer des durées sélectionnées à la réponse du navigateur, mais ne décrit pas en soi l'ensemble des relations de causalité entre les services. Lors de la comparaison, veillez à ce que la trace et l'en-tête se réfèrent aux mêmes opérations et aux mêmes limites.
Lire les temps du serveur via JavaScript
Le API de performance rend les données de synchronisation du serveur existantes accessibles par programmation. Un élément de navigation décrit le chargement du document actuel ; sa propriété serverTiming contient les métriques déclarées disponibles à cet effet. Il s'agit d'une sélection différente de celle d'une entrée correspondant à une ressource chargée ultérieurement ou à un appel d'API.
Exécutez le code JavaScript suivant dans la console du navigateur, sur la page à analyser. Il sélectionne le premier élément de navigation présent et affiche sa liste de temps de serveur sous forme de tableau. Le code ne fait que lire les valeurs déjà disponibles : il ne modifie pas la configuration du serveur et n'effectue aucun test de charge.
S'il n'y a pas d'entrée de navigation ou si celle-ci ne fournit pas de métriques accessibles, l'exemple affiche une liste vide. Cela ne signifie pas pour autant que la page soit rapide ou lente, ni nécessairement que le serveur ne dispose d'aucun outil d'instrumentation. Vérifie d'abord l'en-tête de réponse et assure-toi que l'entrée sélectionnée correspond bien à la requête souhaitée.
Pour une ressource chargée ultérieurement, tu dois plutôt utiliser le Entrée de ressource. Parmi les entrées de type resource tu peux identifier la demande recherchée à partir de son nom et serverTiming-Examine cette propriété. En cas d'appels répétés à la même adresse, tu dois faire attention à l'entrée précise que tu compares.
Pour les ressources provenant de plusieurs origines, l'autorisation appropriée via `Timing-Allow-Origin` détermine également si l'API de performance met à disposition les informations temporelles. La prise en charge par les navigateurs et l'environnement concerné peuvent également influencer le résultat. Comparez donc une liste vide avec l'en-tête brut avant d'apporter des modifications à l'application.
Partages Origin et informations sensibles
Lors d'un accès via l'API Performance, l'origine de la page appelante est déterminante. Si une ressource provient d'une autre origine, sa réponse doit être renvoyée avec Timing-Allow-Origin autoriser correctement l'origine appelante afin que JavaScript puisse lire les informations de synchronisation correspondantes, y compris les informations de synchronisation du serveur. Une autorisation CORS seule ne remplace pas cette autorisation supplémentaire.
A origine précise limite l'autorisation à la source indiquée. Le caractère générique * En revanche, cela autorise en principe toutes les origines à consulter les informations de synchronisation concernées via l'API de performance. Opte donc pour l'autorisation la plus restrictive si une seule application connue a besoin de ces valeurs, et vérifie-les par rapport à la réponse de ressources effectivement fournie.
La divulgation de l'origine ne rend pas un en-tête de réponse non confidentiel. Quiconque reçoit la réponse HTTP peut en principe en examiner le contenu. Ne publiez donc ni identifiants d'accès, ni données à caractère personnel, ni noms d'hôtes internes dans les noms de métriques et les descriptions. Même les durées d'exécution très détaillées peuvent permettre de tirer des conclusions sur les processus internes ; ne communique que les valeurs dont tu as consciemment évalué les avantages et les risques.
Vérifie également le traitement des réponses dans les navigateurs pris en charge par ton application : la prise en charge de certains détails et les exigences relatives aux contextes sécurisés peuvent varier. Pour garantir la sécurité générale des réponses, il convient en outre de en-têtes de sécurité adaptés aux serveurs Web pertinentes ; elles ne remplacent toutefois ni la vérification de l'autorisation de diffusion, ni la décision concernant les valeurs mesurées pouvant être rendues publiques.
Vérifier les valeurs manquantes et les effets de cache
Si la liste des valeurs de synchronisation du serveur est vide, commence par examiner la requête en question dans la section « Réseau » des DevTools. Vérifie, sous « En-têtes », si la réponse renvoyée contient bien un Server-Timing- l'en-tête et les noms qui y figurent. S'il manque, examinez l'instrumentation et les modifications éventuelles apportées par des composants intermédiaires, au lieu de tirer des conclusions sur la vitesse à partir de la liste vide.
Si l'en-tête brut est présent, vérifie ensuite le Entrée relative aux performances: L'entrée de navigation décrit le chargement du document, tandis qu'un appel d'API ou une autre ressource nécessite une entrée de ressource correspondante. Pour les ressources inter-origines, tu dois également vérifier l'autorisation via Timing-Allow-Origin ainsi que la prise en charge par le navigateur utilisé. Une liste vide ne prouve en soi ni l'absence d'instrumentation, ni une réponse rapide ou lente.
Même une valeur existante a besoin de contexte. Un CDN ou un proxy peut fournir ses propres métriques ; parallèlement, une réponse, y compris ses en-têtes, peut provenir d'un cache. Dans ce cas, une métrique « Origin » générée précédemment ne reflète pas nécessairement le travail effectué par le serveur d'origine pour la requête en cours. Il convient donc de documenter État du cache et provenance indépendamment de la durée.
Vérifie, sur l'architecture concrète, quel composant définit l'en-tête, le transmet ou le modifie, et comment il gère les réponses mises en cache. Compare ensuite les requêtes dont l'état du cache est connu, dans la mesure où ton infrastructure le permet. Les différences entre ces réponses constituent des indices utiles, mais sans connaissance des limites de mesure respectives, elles ne constituent pas encore une preuve d'une cause spécifique.
Journaux, bandes-annonces et choix des outils
Server-Timing vient compléter d'autres méthodes de diagnostic, sans pour autant les remplacer. Le choix approprié dépend de votre objectif : comprendre une requête de navigateur isolée, collecter des valeurs existantes par programmation ou analyser les interactions entre plusieurs services. Le tableau suivant présente les informations fournies par chaque méthode, ainsi que leurs conditions préalables et leurs limites.
| Outils | Constat | Condition préalable | Frontière |
|---|---|---|---|
| DevTools | Vérifier les demandes individuelles et les horaires indiqués | Requête du navigateur avec les métriques correspondantes | Pas d'analyse automatique des causes |
| API de performance | Lire les valeurs de synchronisation existantes via JavaScript | Entrée correspondante et, le cas échéant, autorisation « Origin » | Pas de processus inter-services complet |
| fichiers journaux du serveur | Analyser les horaires enregistrés côté serveur | Format de journalisation adapté et accès aux journaux | Les limites de mesure et les unités doivent être vérifiées |
| Traçage distribué | Analyser les liens entre les services concernés | Instrumentation et affectation des traces | Coûts supplémentaires liés à l'exploitation et à l'instrumentation |
Pour un indicateur dont la valeur n'est connue qu'une fois la réponse terminée, une entrée de journal peut s'avérer plus appropriée qu'un en-tête de réponse classique. NGINX consigne par exemple request_time et upstream_response_time en secondes, avec une précision à la milliseconde près. Le « Server-Timing », en revanche, utilise les millisecondes : une valeur exprimée en secondes doit être multipliée par 1 000. Avant de procéder à une comparaison, vérifie également à quel moment chaque mesure commence et se termine.
À l'adresse suivante : Streaming la durée totale du corps de la réponse n'est peut-être pas encore déterminée lors de l'envoi des en-têtes standard. La spécification autorise également l'utilisation de « Server-Timing » en tant que « HTTP-Trailer ». Il ne s'agit toutefois pas d'une solution universelle : l'API Fetch ne donne pas accès aux « Trailers », et leur affichage dans les outils de développement doit être vérifié séparément pour chaque navigateur.
Pour obtenir des comparaisons plus fiables, répétez des requêtes similaires dans des conditions documentées : notez notamment le point de terminaison, l'état du cache et les modifications pertinentes apportées au système. Examinez plusieurs valeurs plutôt qu’une seule requête et analysez plus en détail les différences notables à l’aide des journaux ou des traces. Cela permet de voir clairement quelle observation est réellement couverte par quelle mesure.
Un environnement de test basé sur un navigateur peut faciliter l'expérimentation des paramètres d'une application, mais il ne reproduit pas automatiquement les chemins réseau et les services serveur de l'environnement d'exploitation ultérieur. Cela vaut également pour WordPress Playground dans le navigateur. Tu vérifies également les informations relatives à une configuration concrète d'hébergement et de backend dans un environnement aussi proche que possible de l'environnement de production.
Sources et état des connaissances
État de la recherche :
État des recherches : 13 novembre 2026. L'affichage dans le navigateur et la prise en charge de certaines fonctionnalités peuvent varier ; les exemples ne contiennent pas de mesures propres.
https://www.w3.org/TR/server-timing/
https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/serverTiming
https://developer.chrome.com/docs/devtools/network?hl=en
https://developer.chrome.com/docs/devtools/performance/reference/
https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Timing-Allow-Origin
https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Server-Timing
https://docs.nginx.com/nginx/admin-guide/monitoring/logging/




