Um die PHP-Ausführungszeit von Netzwerk und Frontend abzugrenzen, misst du zunächst ein klar definiertes Codeintervall mit hrtime() und vergleichst es mit Browser- und Serverwerten desselben Requests. Ein einzelner Zeitwert ist keine vollständige Zeitbilanz: Der PHP-Timer enthält auch Wartezeiten innerhalb seines Intervalls, während Browser-Timings andere Grenzen haben. Server-Timing kann ergänzende Werte übertragen, misst sie aber nicht selbst. Cache-Zustand, vorläufige Antworten und verschachtelte Messungen musst du beim Vergleich berücksichtigen.
Was die Zeitwerte tatsächlich zeigen
Eine langsam sichtbare Seite kann an mehreren Stellen Zeit verlieren: beim Warten auf eine Antwort, in PHP, bei Datenbankabfragen oder später bei der Verarbeitung im Browser. Ein einzelner Wert für die PHP-Ausführungszeit kann diese Ursachen nicht auseinanderhalten. Entscheidend ist, welchen Abschnitt eines konkreten Requests ein Messwert überhaupt erfasst.
Ein PHP-Timer misst die verstrichene Zeit zwischen zwei Aufrufen im Anwendungscode. Liegt ein Datenbank- oder API-Aufruf dazwischen, zählt dessen Wartezeit mit. Das Ergebnis ist daher keine reine CPU-Zeit und sagt auch nichts über Code aus, der vor dem Start oder nach dem Ende des Timers läuft.
Der Browser beobachtet dagegen Ereignisse aus seiner eigenen Perspektive: etwa den Beginn einer Anfrage und das Eintreffen einer Antwort. Bei einem dynamischen Dokument-Request liegen zwischen diesen Ereignissen möglicherweise Netzwerkwege, Proxy-Verarbeitung und serverseitige Arbeit. Welche Anteile enthalten sind, hängt von den jeweiligen Ereignissen und dem tatsächlichen Antwortpfad ab.
Der HTTP-Header Server-Timing übermittelt zusätzlich benannte Werte, die beispielsweise die Anwendung selbst ermittelt. Er misst nicht automatisch den gesamten Serverweg. Ein Wert für einen Datenbankaufruf kann außerdem innerhalb des Anwendungsintervalls liegen; beide Zahlen lassen sich dann nicht zu einer Gesamtdauer addieren.
Vergleiche die Perspektiven für denselben Request, statt sie als lückenlose Zeitbilanz zu behandeln. Ein langes Anwendungsintervall ist ein Ansatzpunkt für die Suche im Backend. Ein kurzes Intervall bei langsamer Browseranzeige zeigt dagegen zunächst nur, dass die Ursache außerhalb dieses ausdrücklich gemessenen Codeabschnitts liegen kann.
Request und Messbedingungen festlegen
Wähle zuerst eine konkrete Route und den zugehörigen Dokument-Request aus, etwa die dynamische Produktseite eines Shops. Halte fest, ob du einen angemeldeten oder anonymen Zustand untersuchst und welche Testdaten verwendet werden. Unterschiedliche Warenkörbe, Berechtigungen oder Inhalte können sonst dazu führen, dass die Anwendung nicht dieselbe Arbeit verrichtet.
Definiere anschließend die Messgrenzen: Wo im PHP-Code beginnt der Timer, wo endet er und welche Datenbank- oder API-Aufrufe liegen dazwischen? Notiere auch, ob die Messung erst nach dem Framework-Start beginnt. Nur mit diesen Angaben lässt sich später beurteilen, was ein kurzer oder langer Wert tatsächlich aussagt.
Trenne Cache-Treffer und Cache-Misses. Liefert ein vorgeschalteter Cache die Antwort ohne PHP, fehlt möglicherweise ein Anwendungswert; das ist kein Nachweis für null Millisekunden PHP-Arbeit. Auch Weiterleitungen solltest du als eigene Requests erfassen, statt ihre Zeiten unbemerkt mit denen des endgültigen Dokuments zu vergleichen.
Wiederhole die Untersuchung unter möglichst vergleichbaren Bedingungen: gleicher Browser, ähnliche Verbindung, gleicher Nutzerzustand und dokumentierter Cache-Status. Ein einzelner Durchlauf kann durch vorübergehende Verzögerungen oder einen anderen Antwortpfad auffallen. Halte deshalb mehrere Werte und ihre Bedingungen fest, statt nur den schnellsten Wert auszuwählen.
Für die Praxis benötigst du Browser-Entwicklerwerkzeuge und für einen PHP-Timer Zugriff auf den Anwendungscode. Verwende eine Testumgebung oder einen dafür freigegebenen Pfad; produktive Änderungen und Lasttests brauchen eine entsprechende Freigabe. Webserver-Logs oder ein Profiler können die Untersuchung ergänzen, sind aber nicht Voraussetzung für jeden ersten Vergleich.
Ordne Browserwert und serverseitige Messung demselben Request zu, etwa über eine datenschutzgerecht behandelte Kennung. Erfasse dafür keine unnötigen personenbezogenen Daten und beschränke den Zugriff auf Diagnoseinformationen. Ohne diese Zuordnung können schon parallele Aufrufe oder ein zwischenzeitlicher Cache-Wechsel einen Vergleich verfälschen.
Browser-Timing richtig einordnen
Öffne in den Entwicklerwerkzeugen den Netzwerkbereich und wähle zunächst den Dokument-Request der untersuchten Navigation. Die Zeitwerte dieses Requests beschreiben nicht automatisch auch Bilder, Stylesheets oder spätere API-Aufrufe. Für solche einzelnen Ressourcen liefert Resource Timing jeweils eine eigene Perspektive; ihre Verarbeitung im Browser ist damit ebenfalls nicht vollständig erklärt.
Der Zeitpunkt requestStart markiert den Beginn der Anfrage aus Browsersicht. responseStart bezeichnet den Beginn einer empfangenen Antwort, während responseEnd das Ende des Antwortempfangs markiert. Die Differenzen beschreiben beobachtete Intervalle; insbesondere ist die Zeit bis zum Antwortbeginn nicht mit einem PHP-Codeintervall gleichzusetzen.
Bei vorläufigen Antworten ist besondere Vorsicht nötig: Eine Antwort wie 103 Early Hints kann bereits bei responseStart berücksichtigt werden. Wo der Browser finalResponseHeadersStart unterstützt, hilft dieser Zeitpunkt beim Blick auf den Beginn der finalen Antwort. Die Differenz zu requestStart darf deshalb nicht pauschal als Wartezeit bis zum finalen HTML-Header bezeichnet werden.
Cache, Service Worker, Weiterleitungen und eine wiederverwendete Verbindung beeinflussen, welchen Weg ein Request nimmt und wie seine Zeiten zu lesen sind. Bei Ressourcen anderer Ursprünge können einzelne Angaben ohne passende Freigabe fehlen oder null sein. Prüfe diese Bedingungen, bevor du zwei Browserwerte miteinander vergleichst.
Ist die Browser-Wartezeit hoch, das gemessene PHP-Intervall aber kurz, folgt daraus noch kein Netzwerkproblem. Zeit kann auch in einem Proxy oder in einer Warteschlange vor dem PHP-Messpunkt vergehen. Besonders vorsichtig ist der Vergleich, wenn PHP-Arbeit erst nach einer vorläufigen Antwort stattfindet: Die beiden Intervalle haben dann unterschiedliche Grenzen.
PHP-Code mit hrtime messen
Mit hrtime(true) misst du die verstrichene Zeit zwischen zwei selbst gewählten Stellen im PHP-Code. Die Funktion verwendet eine monotone Zeitbasis: Für die Dauer bildest du die Differenz zweier Aufrufe, statt einen Zeitpunkt als Uhrzeit zu interpretieren. Das gemessene Intervall kann auch Wartezeiten enthalten und ist daher keine reine CPU-Zeit.
Lege für das folgende Beispiel eine isolierte Testdatei in einer freigegebenen Umgebung mit PHP ab 7.3 an. Rufe sie über den Webserver auf, damit du den Antwortheader anschließend in den Browser-Entwicklerwerkzeugen prüfen kannst. Der Platzhalter steht für den Anwendungsteil, dessen Beginn und Ende du bewusst festlegst.
Die Funktion liefert den Zahlenwert in Nanosekunden; durch Division durch eine Million entsteht die Dauer in Millisekunden. Auf 32-Bit-Systemen kann der Rückgabewert ein Float sein. Die Fehlerprüfung verhindert, dass bei einem Rückgabewert von false eine ungültige Dauer ausgegeben wird. Die Einheit Nanosekunden garantiert für sich genommen keine entsprechende Messgenauigkeit.
Im Beispiel endet das Intervall vor dem Setzen des Headers und vor der Ausgabe. Es erfasst deshalb weder diese Schritte noch Arbeit, die vor dem ersten oder nach dem zweiten Zeitstempel stattfindet. Setzt du den Start erst nach dem Framework-Start, fehlt auch dessen vorherige Initialisierung im Ergebnis.
Ersetzt du den Platzhalter durch einen Datenbank- oder API-Aufruf, zählt dessen Wartezeit zum Intervall. Ein hoher Wert zeigt damit zunächst, dass der eingerahmte Abschnitt lange dauerte; er unterscheidet noch nicht zwischen PHP-Berechnung und Warten auf andere Dienste. Für diese Unterscheidung brauchst du weitere, enger gesetzte Messpunkte.
Messwerte per Server-Timing übertragen
Der Header Server-Timing übermittelt benannte Metriken an den Client. Er misst die Dauer nicht selbst: Die Anwendung oder eine beteiligte Serverkomponente muss den Wert zuvor ermitteln. Für dur empfiehlt die Spezifikation Millisekunden; der Name beschreibt die Metrik, nicht automatisch ihre Messgrenzen.
Im PHP-Beispiel muss der Header vor tatsächlich gesendeter Ausgabe gesetzt werden. Der zweite Parameter false bei header() fügt ein weiteres Headerfeld hinzu, statt ein bestehendes gleichnamiges Feld zu ersetzen. In einem Framework ist eine Response-Middleware oft ein geeigneter Integrationspunkt, sofern die Messung dort bereits abgeschlossen ist und die Header noch nicht gesendet wurden.
Der folgende HTTP-Antwortheader zeigt zwei fiktive Werte; er ist keine Messung. Angenommen, das Datenbankintervall liegt vollständig innerhalb des Anwendungsintervalls, dann sind die Werte verschachtelt. Die 75 Millisekunden für die Datenbank sind bereits in den 120 Millisekunden für die Anwendung enthalten und dürfen nicht hinzuaddiert werden.
Die Differenz von 45 Millisekunden beschreibt unter dieser Annahme lediglich die übrige Zeit innerhalb von app. Sie ist nicht automatisch PHP-CPU-Zeit: Auch dort können andere Wartezeiten enthalten sein. Dokumentiere deshalb für jede Metrik, wo sie beginnt und endet und ob sie andere Intervalle einschließt.
Gib nur bewusst ausgewählte, hinreichend grobe Werte aus. Metriknamen und Beschreibungen können Infrastrukturdetails offenlegen; personenbezogene Daten gehören nicht in den Header. Der ursprungsübergreifende Zugriff auf Timing-Daten über JavaScript ist eingeschränkt und kann mit Timing-Allow-Origin gesteuert werden. Eine solche Freigabe solltest du gezielt für die benötigten Ursprünge prüfen.
Messintervalle im Vergleich
Die Größen in der Tabelle beantworten unterschiedliche Fragen. Vergleiche sie möglichst für denselben Request und notiere die jeweiligen Grenzen: Ein im Browser sichtbares Intervall beginnt und endet nicht automatisch an denselben Stellen wie ein PHP-Timer oder ein NGINX-Logwert. Besonders wichtig ist außerdem die Einheit: Millisekunden und Sekunden dürfen nicht ungeprüft nebeneinander ausgewertet werden.
| Messgröße | Beginn und Ende | Einheit | Wartezeiten und Einschränkung |
|---|---|---|---|
| PHP-Codeintervall | Zwischen zwei selbst gesetzten hrtime-Aufrufen | Nanosekunden als Zahlenwert; oft in Millisekunden umgerechnet | Enthält Wartezeiten innerhalb des Abschnitts; keine reine CPU-Zeit und kein vollständiger Request. |
| Server-Timing-Metrik | Durch die messende Komponente festgelegt | Für dur sind Millisekunden empfohlen | Übermittelt einen ermittelten Wert; enthaltene Wartezeiten hängen von den definierten Grenzen ab. |
| Browser-Requestintervall | requestStart bis responseStart | Millisekunden | Umfasst aus Browsersicht beobachtete Wartezeit; responseStart kann eine vorläufige Antwort erfassen. |
| Browser-Antwortintervall | responseStart bis responseEnd | Millisekunden | Beschreibt das beobachtete Antwortintervall; nicht mit reiner PHP-Ausführung gleichsetzen. |
| NGINX-Request-Zeit | Erstes Lesen von Client-Bytes bis zum Log-Schreiben nach dem Senden der letzten Bytes | Sekunden | Umfasst den Request aus NGINX-Sicht einschließlich Wartezeiten; Grenzen unterscheiden sich vom PHP-Timer. |
Prüfe das tatsächliche Logformat, bevor du einen Wert als Dauer des gesamten Backends interpretierst. Die NGINX-Request-Zeit hat einen eigenen Rahmen: Sie beginnt bereits beim Lesen der ersten Client-Bytes und reicht bis zum Log-Schreiben nach dem Senden der letzten Bytes.
Browser- und Serverwerte lassen sich als ergänzende Perspektiven nutzen, aber nicht ohne Prüfung zu einer lückenlosen Zeitbilanz addieren oder voneinander abziehen. Messbereiche können sich überschneiden, und Client- und Serveruhren sind nicht zuverlässig synchronisiert. Halte deshalb neben jedem Wert fest, welcher Request und welcher Antwortpfad tatsächlich beobachtet wurden.
Logs und PHP-FPM ergänzen
Ein Anwendungstimer zeigt nur den eingerahmten Code. Ergänzende Server-Logs helfen, denselben Request aus einer anderen Perspektive zu betrachten. Ordne dafür den PHP-Wert und den Log-Eintrag anhand einer datenschutzgerecht vergebenen Request-Kennung zu. Prüfe zunächst, ob tatsächlich derselbe Antwortpfad durchlaufen wurde und keine Weiterleitung mit einer eigenen Anfrage verwechselt wird.
Bei NGINX beginnt $request_time mit dem Lesen der ersten Client-Bytes und endet beim Schreiben des Logs nach dem Senden der letzten Antwort-Bytes. Diese Größe hat andere Grenzen als ein Timer innerhalb der PHP-Anwendung und ist deshalb nicht mit ihm gleichzusetzen.
Prüfe das konfigurierte Logformat und die Messgrenzen, bevor du einen Logwert als PHP-Laufzeit behandelst. Die Hosting-Latenz-Analyse für Netzwerk, PHP und Datenbank bietet weitere Ansatzpunkte für die Untersuchung des gesamten Antwortpfads.
Auch das Ende der sichtbaren Antwort muss nicht das Ende der PHP-Arbeit sein. Mit fastcgi_finish_request() kann PHP-FPM die Antwort abschließen und anschließend weiteren Code ausführen. Für die Beurteilung der Worker-Belastung benötigst du daher zusätzlich serverseitige Beobachtung; ein kurzer clientseitiger Wert schließt spätere Arbeit nicht aus.
Bei Streaming oder bereits gesendeten Headern lässt sich ein später ermittelter Gesamtwert nicht mehr zuverlässig im ursprünglichen Antwortheader unterbringen. Nutze dafür geeignete Logs oder Tracing. Beschränke Zugriff und Aufbewahrung auf das Nötige und vermeide personenbezogene Daten oder vertrauliche Inhalte in Messwerten und Korrelationskennungen.
Datenbank, API und Frontend eingrenzen
Ist das Anwendungsintervall lang, zerlege es an fachlich sinnvollen Stellen in kleinere Intervalle. Ein separat gemessener Datenbankaufruf kann zeigen, wie viel verstrichene Zeit innerhalb dieses Aufrufs liegt. Der Wert umfasst aus Anwendungssicht gegebenenfalls auch Verbindungs- und Übertragungszeiten und ist nicht mit der reinen Rechenzeit der Datenbank gleichzusetzen.
Ein langer Datenbankwert ist eine Hypothese für den nächsten Schritt, keine fertige Diagnose. Prüfe die betroffene Abfrage mit den verfügbaren Datenbank-Diagnosewerkzeugen und ihrem Ausführungsplan. Erst dort lässt sich untersuchen, ob etwa ein ungünstiger Zugriffspfad oder eine andere Ursache beteiligt ist; der PHP-Timer allein beweist keinen fehlenden Index.
Für eine externe API setzt du einen weiteren Timer unmittelbar um den ausgehenden Aufruf. Ein langes API-Intervall zeigt, wo die Anwendung wartet, aber nicht automatisch, warum. Untersuche mit detaillierten Client-Timings oder Tracing, soweit verfügbar, ob etwa Namensauflösung, Verbindungsaufbau, die Gegenseite oder die Übertragung auffällig ist.
Kommt das HTML zügig an, die Seite wirkt aber weiterhin langsam, wechsle zur Browserperspektive. Untersuche die einzelnen Ressourcen-Requests und anschließend die JavaScript-Verarbeitung und Darstellung. Der PHP-Timer des Dokuments erfasst weder automatisch spätere Ressourcenanfragen noch die vollständige Arbeit des Browsers; auch für diese Schritte brauchst du eigene Beobachtungen.
Fehlt ein PHP-Messwert, prüfe zunächst den Cache-Pfad: Ein vorgeschalteter Cache kann eine Antwort liefern, ohne PHP für diesen Request aufzurufen. Das Fehlen des Headers bedeutet deshalb nicht, dass PHP null Millisekunden benötigt hat. Halte Cache-Treffer und dynamische Antworten getrennt fest und vergleiche nur entsprechend zugeordnete Requests.
Ergebnisse bewerten und weiterprüfen
Bevor du aus auffälligen Zahlen eine Maßnahme ableitest, kontrolliere ihre Zuordnung: Gehören Browserereignis, Header und Log wirklich zum selben Request? Unterschiedliche Nutzerzustände, Cache-Treffer oder Weiterleitungen können ansonsten scheinbare Unterschiede erzeugen. Dokumentiere außerdem die Grenzen und Einheiten jedes Werts, bevor du mehrere Durchläufe vergleichst.
Bei verschachtelten Intervallen darfst du die Teilzeit nicht zur umfassenden Zeit addieren. Eine Differenz zwischen Anwendung und Datenbank ist ebenfalls nicht automatisch PHP-CPU-Zeit; sie beschreibt zunächst nur die übrige verstrichene Zeit innerhalb der gewählten Grenzen. Ebenso ist die Differenz zwischen Browser- und Anwendungsmessung nicht ohne Weiteres reine Netzwerkzeit.
Ist das definierte Anwendungsintervall wiederholt lang, aber der teure Code noch unbekannt, ist ein Profiler der nächste sinnvolle Schritt. Er kann helfen, die Untersuchung auf bestimmte Funktionen und Aufrufpfade zu richten. Lege dabei offen, welchen Request und welchen Abschnitt du profilierst, statt das Ergebnis auf jede Seite der Anwendung zu übertragen.
Geht es dagegen um Verhalten bei gleichzeitigen Zugriffen, reicht die Messung einer einzelnen Anfrage nicht. Plane einen reproduzierbaren Anwendungstest unter freigegebenen Bedingungen und berücksichtige erfolgreiche Antworten, Fehler und Antwortzeiten. Der Beitrag zum Server-CPU-Benchmarking für reale PHP-Workloads erläutert, wie sich eine Rechenaufgabe und ein Anwendungstest voneinander abgrenzen lassen.
Beziehe schließlich auch Arbeit nach Antwortabschluss in die Bewertung ein: Bei Verwendung von fastcgi_finish_request() kann ein schneller Browserabschluss mit weiterer PHP-Arbeit zusammenfallen. Wähle daher die nächste Messung nach der offenen Frage: sichtbare Antwortzeit, Dauer eines Codeabschnitts oder Belastung des Workers sind unterschiedliche Ziele.
Quellen und fachlicher Stand
Recherche-Stand:
Recherchestand: 13. November 2026. Das hrtime-Beispiel setzt PHP ab 7.3 voraus; Server-Timing wird anhand des W3C-Arbeitsentwurfs vom 2. November 2026 eingeordnet.
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




