Pour distinguer le temps d'exécution PHP du réseau et du front-end, commence par mesurer un intervalle de code clairement défini à l'aide de hrtime() et tu le compares aux valeurs du navigateur et du serveur pour cette même requête. Une seule valeur temporelle ne constitue pas un bilan temporel complet: Le timer PHP inclut également les temps d'attente dans son intervalle, tandis que les mesures de temps du navigateur ont d'autres limites. Les mesures de temps du serveur peuvent transmettre des valeurs complémentaires, mais ne les mesurent pas elles-mêmes. Tu dois tenir compte de l'état du cache, des réponses provisoires et des mesures imbriquées lors de la comparaison.
Ce que révèlent réellement les valeurs actuelles
Une page qui met du temps à s'afficher peut subir des pertes de temps à plusieurs niveaux : lors de l'attente d'une réponse, dans le code PHP, lors des requêtes à la base de données ou plus tard lors du traitement dans le navigateur. Une valeur unique pour la Temps d'exécution PHP ne peut pas distinguer ces causes. Ce qui est déterminant, c'est la partie d'une requête spécifique qu'une valeur mesurée enregistre.
Un timer PHP mesure le temps écoulé entre deux appels dans le code de l'application. Si un appel à la base de données ou à une API a lieu entre ces deux appels, son temps d'attente est également pris en compte. Le résultat ne correspond donc pas uniquement au temps CPU et ne fournit aucune information sur le code exécuté avant le démarrage ou après la fin du timer.
Le navigateur, quant à lui, observe les événements de son propre point de vue : par exemple, le début d'une requête et la réception d'une réponse. Dans le cas d’une requête de document dynamique, ces événements peuvent être séparés par des trajets réseau, un traitement par proxy et des opérations côté serveur. Les éléments concernés dépendent des événements en question et du chemin de réponse effectif.
L'en-tête HTTP Temporisation du serveur Il transmet également des valeurs spécifiques, déterminées par exemple par l'application elle-même. Il ne mesure pas automatiquement l'ensemble du parcours sur le serveur. De plus, la durée d'une requête de base de données peut se situer dans l'intervalle de mesure de l'application ; dans ce cas, ces deux chiffres ne peuvent pas être additionnés pour obtenir une durée totale.
Comparez les perspectives pour la même requête, au lieu de les considérer comme un historique temporel continu. Un long intervalle d'application constitue un point de départ pour la recherche dans le backend. En revanche, un intervalle court associé à un affichage lent dans le navigateur indique dans un premier temps uniquement que la cause peut se situer en dehors de cette section de code expressément mesurée.
Définir la requête et les conditions de mesure
Commence par choisir un parcours concret et la requête de document correspondante, par exemple la page produit dynamique d'une boutique en ligne. Précisez si vous examinez un état connecté ou anonyme, et quelles données de test sont utilisées. Sinon, des paniers, des autorisations ou des contenus différents peuvent entraîner un fonctionnement différent de l'application.
Définissez ensuite la Limites de mesure: Dans le code PHP, où commence le chronomètre, où s'arrête-t-il et quels appels à la base de données ou à l'API se situent entre ces deux points ? Notez également si la mesure ne commence qu'après le démarrage du framework. Ce n'est qu'avec ces informations qu'il sera possible d'évaluer ultérieurement ce que signifie réellement une valeur courte ou longue.
Distinguez les accès au cache réussis des échecs de cache. Si un cache en amont fournit la réponse sans passer par PHP, une valeur de l'application peut manquer ; cela ne prouve pas pour autant que le temps d'exécution PHP soit de zéro milliseconde. Tu devrais également enregistrer les redirections comme des requêtes distinctes, plutôt que de comparer leurs durées, sans t'en rendre compte, à celles du document final.
Répétez le test dans des conditions aussi comparables que possible : même navigateur, connexion similaire, même état de l'utilisateur et état du cache documenté. Un seul test peut présenter des anomalies dues à des retards temporaires ou à un chemin de réponse différent. Enregistrez donc plusieurs valeurs et leurs conditions, plutôt que de vous contenter de sélectionner la valeur la plus rapide.
Pour les exercices pratiques, tu auras besoin des outils de développement du navigateur et, pour un minuteur PHP, d'un accès au code de l'application. Utilise un environnement de test ou un chemin d'accès validé à cet effet ; les modifications en production et les tests de charge nécessitent une autorisation appropriée. Les journaux du serveur web ou un profileur peuvent compléter l'analyse, mais ne sont pas indispensables pour une première comparaison.
Associez la valeur du navigateur et la mesure côté serveur à la même requête, par exemple à l'aide d'un identifiant traité dans le respect de la protection des données. Pour ce faire, ne collectez pas de données à caractère personnel inutiles et limitez l'accès aux informations de diagnostic. Sans cette association, de simples appels parallèles ou un changement intermédiaire de cache peuvent déjà fausser la comparaison.
Bien comprendre le « Browser Timing »
Dans les outils de développement, ouvrez la section « Réseau » et sélectionnez tout d'abord la requête de document correspondant à la navigation étudiée. Les valeurs temporelles de cette requête ne couvrent pas automatiquement les images, les feuilles de style ou les appels d’API ultérieurs. Pour chacune de ces ressources individuelles, Resource Timing fournit une perspective distincte ; leur traitement par le navigateur n’est donc pas non plus entièrement expliqué.
La date requestStart marque le début de la requête du point de vue du navigateur. responseStart indique le début d'une réponse reçue, tandis que responseEnd qui marque la fin de la réception de la réponse. Les différences correspondent à des intervalles observés ; en particulier, le temps écoulé jusqu'au début de la réponse ne doit pas être assimilé à un intervalle de code PHP.
À l'adresse suivante : réponses provisoires il faut redoubler de prudence : une réponse telle que « 103 Early Hints » peut déjà, dès responseStart doit être pris en compte. Lorsque le navigateur finalResponseHeadersStart soutenu, ce moment aide à entrevoir le début de la réponse finale. La différence par rapport à requestStart ne doit donc pas être qualifié de manière générale de « délai d'attente jusqu'à l'en-tête HTML définitif ».
Le cache, les Service Workers, les redirections et la réutilisation d'une connexion influencent le chemin emprunté par une requête et la manière dont ses temps doivent être interprétés. Pour les ressources provenant d'autres origines, certaines informations peuvent manquer ou être nulles si l'autorisation appropriée n'est pas accordée. Vérifie ces conditions avant de comparer deux valeurs de navigateur entre elles.
Si le temps d'attente du navigateur est élevé, mais que l'intervalle PHP mesuré est court, cela ne signifie pas pour autant qu'il y ait un problème réseau. Du temps peut également s'écouler au niveau d'un proxy ou dans une file d'attente en amont du point de mesure PHP. La comparaison doit être effectuée avec une prudence particulière lorsque le traitement PHP n'a lieu qu'après une réponse préliminaire : les deux intervalles ont alors des limites différentes.
Mesurer le code PHP avec hrtime
Avec hrtime(true) vous mesurez le temps écoulé entre deux points que vous avez vous-même choisis dans le code PHP. La fonction utilise une base de temps monotone: Pendant cette durée, tu calcules la différence entre deux appels, au lieu d'interpréter un instant donné comme une heure. L'intervalle mesuré peut également inclure des temps d'attente et ne correspond donc pas à un temps CPU pur.
Pour l'exemple suivant, créez un fichier de test isolé dans un environnement partagé avec PHP 7.3 ou une version ultérieure. Accédez-y via le serveur web afin de pouvoir ensuite vérifier l'en-tête de réponse dans les outils de développement du navigateur. Le caractère de remplacement représente la partie de l'application dont vous définissez délibérément le début et la fin.
Cette fonction renvoie une valeur numérique exprimée en nanosecondes ; en la divisant par un million, on obtient la durée en millisecondes. Sur les systèmes 32 bits, la valeur renvoyée peut être un nombre à virgule flottante. Le contrôle d'erreur empêche, lorsque la valeur renvoyée est false une durée non valide est renvoyée. L'unité « nanosecondes » ne garantit pas à elle seule une précision de mesure suffisante.
Dans cet exemple, l'intervalle se termine avant la définition de l'en-tête et avant l'affichage. Il ne prend donc en compte ni ces étapes, ni le travail effectué avant le premier horodatage ou après le deuxième. Si tu ne définis le début qu'après le démarrage du framework, son initialisation préalable ne sera pas non plus prise en compte dans le résultat.
Si tu remplaces l'espace réservé par un appel à la base de données ou à une API, le temps d'attente correspondant est pris en compte dans l'intervalle. Une valeur élevée indique donc dans un premier temps que la section encadrée a duré longtemps ; elle ne fait pas encore la distinction entre le calcul PHP et l'attente d'autres services. Pour établir cette distinction, tu as besoin de points de mesure supplémentaires, plus rapprochés.
Transmission des valeurs mesurées via le timing du serveur
L'en-tête Server-Timing transmet les métriques indiquées au client. Il ne mesure pas lui-même la durée : l'application ou un composant serveur impliqué doit d'abord déterminer cette valeur. Pour dur recommande d'utiliser la spécification « millisecondes » ; le nom décrit la métrique, mais ne définit pas automatiquement ses limites de mesure.
Dans l'exemple PHP, l'en-tête doit être défini avant l'envoi effectif de la sortie. Le deuxième paramètre false à l'adresse suivante : header() ajoute un champ d'en-tête supplémentaire, au lieu de remplacer un champ existant portant le même nom. Dans un framework, un middleware de réponse constitue souvent un point d'intégration approprié, à condition que la mesure y soit déjà terminée et que les en-têtes n'aient pas encore été envoyés.
L'en-tête de réponse HTTP suivant présente deux valeurs fictives ; il ne s'agit pas d'une mesure. En supposant que l'intervalle de la base de données se situe entièrement dans l'intervalle de l'application, les valeurs sont alors imbriqué. Les 75 millisecondes correspondant à la base de données sont déjà incluses dans les 120 millisecondes de l'application et ne doivent pas être ajoutées.
Dans cette hypothèse, la différence de 45 millisecondes correspond simplement au temps restant au sein de app. Il ne s'agit pas systématiquement du temps CPU PHP : d'autres temps d'attente peuvent également y être inclus. Il convient donc de documenter, pour chaque indicateur, où il commence et où il se termine, et s'il inclut d'autres intervalles.
N'affichez que des valeurs soigneusement sélectionnées et suffisamment approximatives. Les noms et descriptions des métriques peuvent révéler des détails sur l'infrastructure ; les données à caractère personnel n'ont pas leur place dans l'en-tête. L'accès inter-origines aux données de chronométrage via JavaScript est limité et peut être restreint à l'aide de Timing-Allow-Origin être contrôlée. Tu devrais vérifier de manière ciblée si cette autorisation s'applique bien aux sources requises.
Comparaison des intervalles de mesure
Les valeurs du tableau répondent à différentes questions. Comparez-les si possible pour une même requête et notez les limites correspondantes : un intervalle visible dans le navigateur ne commence ni ne se termine automatiquement aux mêmes endroits qu’un minuteur PHP ou une entrée du journal NGINX. Il est également particulièrement important de noter la Unité: Les millisecondes et les secondes ne doivent pas être évaluées côte à côte sans vérification préalable.
| Grandeur de mesure | Début et fin | Unité | Délais d'attente et restrictions |
|---|---|---|---|
| Intervalle de code PHP | Entre deux appels à la fonction `hrtime` que l'on a soi-même déclenchés | Les nanosecondes exprimées sous forme numérique ; souvent converties en millisecondes | Comprend les temps d'attente au sein de la section ; ne comprend ni le temps CPU pur ni la requête complète. |
| Mesure de synchronisation du serveur | Déterminé par le composant de mesure | Pour cela, il est recommandé d'utiliser des millisecondes | Transmet une valeur calculée ; les délais d'attente associés dépendent des limites définies. |
| Intervalle entre les requêtes du navigateur | de requestStart à responseStart | Millisecondes | Englobe le temps d'attente observé du point de vue du navigateur ; la propriété `responseStart` peut enregistrer une réponse provisoire. |
| Intervalle de réponse du navigateur | de responseStart à responseEnd | Millisecondes | Décrit l'intervalle de réponse observé ; ne doit pas être confondu avec l'exécution pure en PHP. |
| Temps de traitement des requêtes NGINX | Première lecture des octets du client jusqu'à l'écriture dans le journal après l'envoi des derniers octets | secondes | Couvre la requête du point de vue de NGINX, y compris les temps d'attente ; les limites diffèrent de celles du minuteur PHP. |
Vérifie le format réel du fichier journal avant d'interpréter une valeur comme correspondant à la durée totale du backend. Le temps de requête NGINX suit son propre cadre : il commence dès la lecture des premiers octets du client et s'étend jusqu'à l'écriture dans le fichier journal après l'envoi des derniers octets.
Les valeurs du navigateur et du serveur peuvent être utilisées comme perspectives complémentaires, mais ne doivent pas être additionnées ou soustraites les unes des autres pour obtenir un bilan temporel complet sans vérification préalable. Les plages de mesure peuvent se chevaucher, et les horloges du client et du serveur ne sont pas synchronisées de manière fiable. C'est pourquoi il convient de noter, à côté de chaque valeur, quelle requête et quel chemin de réponse ont effectivement été observés.
Compléter les fichiers journaux et PHP-FPM
Une minuterie d'application n'affiche que le code encadré. Complémentaire Journaux du serveur aident à examiner cette même requête sous un autre angle. Pour ce faire, associez la valeur PHP et l'entrée du journal à l'aide d'un identifiant de requête attribué dans le respect de la protection des données. Vérifiez d'abord si le même chemin de réponse a bien été suivi et qu'aucune redirection n'est confondue avec une requête distincte.
Avec NGINX, on commence par $request_time Elle commence dès la lecture des premiers octets du client et se termine lors de l'écriture du journal après l'envoi des derniers octets de réponse. Cette durée a des limites différentes de celles d'un temporisateur au sein de l'application PHP et ne doit donc pas être assimilée à celui-ci.
Vérifie le format de journalisation configuré et les limites de mesure avant de traiter une valeur de journal comme une donnée d'exécution PHP. La Analyse de la latence de l'hébergement pour le réseau, PHP et la base de données offre d'autres pistes pour l'analyse de l'ensemble du chemin de réponse.
De même, la fin de la réponse visible ne signifie pas nécessairement la fin du traitement PHP. Avec fastcgi_finish_request() PHP-FPM peut terminer la réponse, puis exécuter du code supplémentaire. Pour évaluer la charge des workers, tu as donc besoin d'une surveillance supplémentaire côté serveur ; une valeur brève côté client n'exclut pas un travail ultérieur.
Dans le cas d'un flux en continu ou d'en-têtes déjà envoyés, une valeur globale déterminée a posteriori ne peut plus être intégrée de manière fiable dans l'en-tête de réponse d'origine. Utilisez à cet effet des journaux ou des outils de traçage adaptés. Limitez l'accès et la conservation au strict nécessaire et évitez d'inclure des données à caractère personnel ou des contenus confidentiels dans les valeurs mesurées et les identifiants de corrélation.
Définir la base de données, l'API et l'interface utilisateur
Si l'intervalle d'exécution est long, divisez-le en intervalles plus courts aux endroits pertinents d'un point de vue technique. Un appel à la base de données mesuré séparément peut indiquer combien de temps s'est écoulé au cours de cet appel. Du point de vue de l'application, cette valeur peut également inclure, le cas échéant, les temps de connexion et de transmission, et ne doit pas être assimilée au temps de calcul pur de la base de données.
Une valeur de base de données longue constitue une hypothèse pour l'étape suivante, et non un diagnostic définitif. Vérifie la requête concernée à l'aide des outils de diagnostic de base de données disponibles et de son plan d'exécution. Ce n'est qu'à ce stade qu'il est possible de déterminer si un chemin d'accès défavorable ou une autre cause est en cause ; le timer PHP ne suffit pas à lui seul à prouver l'absence d'index.
Pour une API externe, tu dois définir un autre minuteur immédiatement après l'appel sortant. Un long Intervalle API indique où l'application est bloquée, mais pas automatiquement pourquoi. À l'aide de mesures détaillées des temps de réponse côté client ou d'un traçage, si disponibles, vérifiez si la résolution des noms, l'établissement de la connexion, le serveur distant ou la transmission présentent des anomalies.
Si le code HTML s'affiche rapidement, mais que la page semble toujours lente, passez en mode « navigateur ». Examinez les différentes requêtes de ressources, puis le traitement JavaScript et l'affichage. Le minuteur PHP du document n'enregistre ni automatiquement les requêtes de ressources ultérieures, ni l'ensemble du travail effectué par le navigateur ; pour ces étapes également, vous devrez vous appuyer sur vos propres observations.
Si une valeur PHP manque, vérifie d'abord le Chemin de la cache: Un cache en amont peut fournir une réponse sans avoir à faire appel à PHP pour cette requête. L'absence d'en-tête ne signifie donc pas que PHP n'a mis zéro milliseconde. Distinguez clairement les réponses issues du cache et les réponses dynamiques, et ne comparez que les requêtes qui leur correspondent.
Évaluer les résultats et poursuivre l'analyse
Avant de tirer des conclusions à partir de chiffres qui sautent aux yeux, vérifie leur attribution : l'événement du navigateur, l'en-tête et le journal appartiennent-ils vraiment à la même requête ? Sinon, des états utilisateur différents, des coups de cache ou des redirections peuvent générer des différences apparentes. Documente également les plages et les unités de chaque valeur avant de comparer plusieurs cycles d'analyse.
À l'adresse suivante : intervalles imbriqués tu ne dois pas ajouter le temps à temps partiel au temps total. De même, la différence entre l'application et la base de données ne correspond pas automatiquement au temps CPU PHP ; elle décrit dans un premier temps uniquement le temps écoulé restant dans les limites choisies. De même, la différence entre les mesures du navigateur et celles de l'application ne correspond pas d'emblée uniquement au temps réseau.
Si l'intervalle d'application défini est particulièrement long, mais que le code coûteux n'est pas encore identifié, l'utilisation d'un profileur constitue la prochaine étape logique. Il peut aider à cibler l'analyse sur des fonctions et des chemins d'appel spécifiques. Précisez clairement quelle requête et quelle section vous profilez, plutôt que d'appliquer le résultat à l'ensemble de l'application.
En revanche, lorsqu'il s'agit d'étudier le comportement en cas d'accès simultanés, la mesure d'une seule requête ne suffit pas. Prévoyez un test d'application reproductible dans des conditions contrôlées et tenez compte des réponses réussies, des erreurs et des temps de réponse. L'article sur le Tests de performances des processeurs de serveurs pour des charges de travail PHP réelles explique comment distinguer un exercice de calcul d'un test d'application.
Enfin, tenez également compte du travail effectué après la fin de la réponse dans l'évaluation : lorsque vous utilisez fastcgi_finish_request() La fermeture rapide du navigateur peut coïncider avec la poursuite du traitement PHP. Choisis donc la mesure suivante en fonction de la question posée : le temps de réponse visible, la durée d'exécution d'un segment de code ou la charge du worker sont des objectifs différents.
Sources et état des connaissances
État de la recherche :
État des recherches : 13 novembre 2026. L'exemple hrtime nécessite PHP 7.3 ou une version ultérieure ; le « server timing » est défini conformément au projet de travail du W3C du 2 novembre 2026.
https://www.php.net/manual/en/function.hrtime.php
https://www.w3.org/TR/2026/WD-server-timing-20261102/
https://www.w3.org/TR/resource-timing/
https://www.php.net/manual/en/book.hrtime.php
https://www.php.net/manual/en/function.header.php
https://nginx.org/en/docs/http/ngx_http_log_module.html
https://www.php.net/fastcgi_finish_request




