...

De uitvoeringstijd van PHP los van het netwerk en de frontend meten

Om de PHP-uitvoeringstijd van het netwerk en de frontend van elkaar te scheiden, meet je eerst een duidelijk gedefinieerd code-interval met hrtime() en vergelijk je dit met de browser- en serverwaarden van hetzelfde verzoek. Een enkele tijdwaarde vormt geen volledige tijdbalans: De PHP-timer houdt ook wachttijden binnen zijn interval bij, terwijl browsertimings andere grenzen hanteren. Server-timing kan aanvullende waarden doorgeven, maar meet deze niet zelf. Bij het vergelijken moet je rekening houden met de cache-status, voorlopige antwoorden en geneste metingen.

Wat de actuele waarden daadwerkelijk laten zien

Een pagina die traag laadt, kan op verschillende momenten tijd verliezen: tijdens het wachten op een antwoord, in PHP, bij databasequery’s of later tijdens de verwerking in de browser. Een enkele waarde voor de PHP-uitvoeringstijd kan deze oorzaken niet van elkaar onderscheiden. Het is van doorslaggevend belang welk deel van een concreet verzoek een meetwaarde überhaupt registreert.

Een PHP-timer meet de verstreken tijd tussen twee aanroepen in de applicatiecode. Als er tussendoor een database- of API-aanroep plaatsvindt, telt de wachttijd daarvan ook mee. Het resultaat is daarom geen pure CPU-tijd en zegt ook niets over code die vóór het starten of na het aflopen van de timer wordt uitgevoerd.

De browser volgt daarentegen gebeurtenissen vanuit zijn eigen perspectief: bijvoorbeeld het begin van een verzoek en de ontvangst van een antwoord. Bij een dynamisch documentverzoek kunnen tussen deze gebeurtenissen netwerkpaden, proxyverwerking en serverzijde-bewerkingen liggen. Welke onderdelen hierin zijn opgenomen, hangt af van de betreffende gebeurtenissen en het daadwerkelijke antwoordpad.

De HTTP-header Server timing verzendt bovendien specifiek genoemde waarden die bijvoorbeeld door de applicatie zelf worden bepaald. Het meet niet automatisch de volledige serverroute. Een waarde voor een database-oproep kan bovendien binnen het interval van de applicatie vallen; beide getallen kunnen dan niet worden opgeteld tot een totale duur.

Vergelijk de perspectieven voor hetzelfde verzoek, in plaats van ze te beschouwen als een ononderbroken tijdlijn. Een lang interval tussen verzoeken is een aanknopingspunt voor het onderzoek in de backend. Een kort interval bij een trage weergave in de browser wijst daarentegen in eerste instantie alleen erop dat de oorzaak buiten dit expliciet gemeten codegedeelte kan liggen.

Verzoek en meetvoorwaarden vaststellen

Kies eerst een specifieke route en de bijbehorende documentaanvraag, bijvoorbeeld de dynamische productpagina van een webwinkel. Noteer of je een aangemelde of anonieme status onderzoekt en welke testgegevens worden gebruikt. Verschillende winkelmandjes, machtigingen of inhoud kunnen er anders toe leiden dat de applicatie niet hetzelfde werk verricht.

Definieer vervolgens de Meetbereik: Waar in de PHP-code begint de timer, waar eindigt hij en welke database- of API-aanroepen zitten daar tussenin? Noteer ook of de meting pas begint nadat het framework is opgestart. Alleen met deze gegevens kan later worden beoordeeld wat een korte of lange waarde daadwerkelijk betekent.

Maak onderscheid tussen cache-treffers en cache-missers. Als een upstream-cache het antwoord levert zonder PHP, ontbreekt mogelijk een applicatiewaarde; dat is geen bewijs voor nul milliseconden PHP-bewerkingstijd. Ook omleidingen moet je als afzonderlijke verzoeken registreren, in plaats van hun tijden onopgemerkt te vergelijken met die van het uiteindelijke document.

Herhaal het onderzoek onder zo vergelijkbaar mogelijke omstandigheden: dezelfde browser, een vergelijkbare verbinding, dezelfde gebruikersstatus en een gedocumenteerde cache-status. Een enkele testrun kan afwijken door tijdelijke vertragingen of een ander antwoordtraject. Leg daarom meerdere waarden en de bijbehorende omstandigheden vast, in plaats van alleen de snelste waarde te selecteren.

Door AI gegenereerde illustratie van twee losse, lege indexkaartjes en een notitieboekje op een bureau
Door AI gegenereerde illustratie: afzonderlijk gedocumenteerde voorwaarden maken het gemakkelijker om meerdere verzoeken met elkaar te vergelijken.

Voor de praktijk heb je browserontwikkelaarstools nodig en, voor een PHP-timer, toegang tot de applicatiecode. Gebruik een testomgeving of een daarvoor vrijgegeven pad; productieve wijzigingen en belastingstests vereisen de juiste goedkeuring. Webserverlogs of een profiler kunnen het onderzoek aanvullen, maar zijn geen vereiste voor elke eerste vergelijking.

Koppel de browserwaarde en de meting aan de serverzijde aan hetzelfde verzoek, bijvoorbeeld via een identificatiecode die in overeenstemming met de privacywetgeving wordt verwerkt. Verzamel hiervoor geen onnodige persoonsgegevens en beperk de toegang tot diagnostische informatie. Zonder deze koppeling kunnen zelfs parallelle verzoeken of een tussentijdse cachewijziging een vergelijking vertekenen.

Browser-timing op de juiste manier interpreteren

Open in de ontwikkelaarstools het netwerkgedeelte en selecteer eerst het documentverzoek van de onderzochte navigatie. De tijdwaarden van dit verzoek hebben niet automatisch betrekking op afbeeldingen, stylesheets of latere API-aanroepen. Voor dergelijke afzonderlijke bronnen biedt Resource Timing telkens een eigen perspectief; de verwerking ervan in de browser wordt daarmee evenmin volledig verklaard.

Het tijdstip requestStart geeft het begin van de verzoek aan vanuit het perspectief van de browser. responseStart duidt het begin van een ontvangen antwoord aan, terwijl responseEnd dit markeert het einde van de ontvangst van het antwoord. De verschillen beschrijven waargenomen intervallen; met name is de tijd tot het begin van het antwoord niet gelijk te stellen aan een PHP-code-interval.

Op voorlopige antwoorden is bijzondere voorzichtigheid geboden: een antwoord zoals 103 Early Hints kan al bij responseStart moet hiermee rekening worden gehouden. Wanneer de browser finalResponseHeadersStart ondersteunt, helpt dit moment bij het in kaart brengen van het begin van het definitieve antwoord. Het verschil met requestStart mag daarom niet zonder meer worden aangeduid als wachttijd tot de definitieve HTML-header.

Cache, service workers, omleidingen en een hergebruikte verbinding beïnvloeden de route die een verzoek aflegt en hoe de bijbehorende tijden moeten worden geïnterpreteerd. Bij bronnen van andere oorsprong kunnen bepaalde gegevens ontbreken of de waarde nul hebben als er geen passende toestemming is. Controleer deze voorwaarden voordat je twee browserwaarden met elkaar vergelijkt.

Als de wachttijd in de browser lang is, maar het gemeten PHP-interval kort, betekent dat nog niet dat er een netwerkprobleem is. Er kan ook tijd verstrijken in een proxy of in een wachtrij vóór het PHP-meetpunt. De vergelijking is bijzonder lastig wanneer PHP-bewerkingen pas plaatsvinden na een voorlopig antwoord: de twee intervallen hebben dan verschillende grenzen.

PHP-code met hrtime meten

Met hrtime(true) meet je de verstreken tijd tussen twee zelfgekozen punten in de PHP-code. De functie maakt gebruik van een monotone tijdbasis: Gedurende deze periode bereken je het verschil tussen twee aanroepen, in plaats van een tijdstip als kloktijd te interpreteren. Het gemeten interval kan ook wachttijden bevatten en is daarom geen pure CPU-tijd.

Maak voor het volgende voorbeeld een geïsoleerd testbestand aan in een gedeelde omgeving met PHP 7.3 of hoger. Roep het op via de webserver, zodat je de responsheader vervolgens kunt controleren in de ontwikkelaarstools van de browser. De plaatshouder staat voor het gedeelte van de applicatie waarvan je zelf het begin en einde bepaalt.

Code
<?php
$start = hrtime(true);

// Hier den zu untersuchenden Anwendungsteil ausführen.
$result = 'Testantwort';

$end = hrtime(true);

if ($start !== false && $end !== false) {
    $durationMs = ($end - $start) / 1000000;
    header('Server-Timing: app;dur=' . sprintf('%.3F', $durationMs), false);
}

echo $result;

De functie retourneert de waarde in nanoseconden; door deze door een miljoen te delen, krijg je de duur in milliseconden. Op 32-bits systemen kan de retourwaarde een float zijn. De foutcontrole voorkomt dat bij een retourwaarde van false er wordt een ongeldige duur weergegeven. De eenheid nanoseconden garandeert op zichzelf geen overeenkomstige meetnauwkeurigheid.

In het voorbeeld eindigt het interval vóór het instellen van de header en vóór de uitvoer. Het omvat daarom noch deze stappen, noch werkzaamheden die plaatsvinden vóór het eerste of na het tweede tijdstempel. Als je de start pas na het opstarten van het framework instelt, ontbreekt ook de voorafgaande initialisatie daarvan in het resultaat.

Als je de plaatshouder vervangt door een database- of API-aanroep, telt de wachttijd daarvan mee voor het interval. Een hoge waarde geeft dus in eerste instantie aan dat het omkaderde gedeelte lang duurde; er wordt nog geen onderscheid gemaakt tussen PHP-berekeningen en het wachten op andere diensten. Voor dit onderscheid heb je meer, dichter bij elkaar gelegen meetpunten nodig.

Meetwaarden via server-timing verzenden

De koptekst Server-Timing stuurt de genoemde statistieken naar de client. Hij meet de duur niet zelf: de applicatie of een betrokken servercomponent moet de waarde eerst bepalen. Voor dur De specificatie raadt milliseconden aan; de naam beschrijft de maatstaf, niet automatisch de meetgrenzen ervan.

In het PHP-voorbeeld moet de header worden ingesteld voordat de uitvoer daadwerkelijk wordt verzonden. De tweede parameter false op header() voegt een extra headerveld toe, in plaats van een bestaand veld met dezelfde naam te vervangen. In een framework is response-middleware vaak een geschikt integratiepunt, mits de meting daar al is voltooid en de headers nog niet zijn verzonden.

De volgende HTTP-antwoordheader toont twee fictieve waarden; het is geen meting. Stel dat het database-interval volledig binnen het applicatie-interval valt, dan zijn de waarden genest. De 75 milliseconden voor de database zijn al inbegrepen in de 120 milliseconden voor de toepassing en mogen niet worden opgeteld.

Door AI gegenereerde illustratie van een deelinterval dat volledig binnen een groter interval ligt
Door AI gegenereerde illustratie: een opgenomen database-interval wordt niet bij de gebruiksduur opgeteld.
Code
Server-Timing: app;dur=120.000, db;dur=75.000

Het verschil van 45 milliseconden geeft, uitgaande van deze aanname, slechts de resterende tijd binnen app. Het gaat hier niet automatisch om PHP-CPU-tijd: ook daar kunnen andere wachttijden in zijn meegenomen. Documenteer daarom voor elke statistiek waar deze begint en eindigt en of er andere intervallen in zijn meegenomen.

Geef alleen bewust gekozen, voldoende ruwe waarden weer. Namen en beschrijvingen van statistieken kunnen details over de infrastructuur onthullen; persoonsgegevens horen niet in de header thuis. Toegang tot timinggegevens vanuit verschillende bronnen via JavaScript is beperkt en kan worden geregeld met Timing-Allow-Origin worden aangestuurd. Je moet een dergelijke vrijgave gericht controleren voor de benodigde bronnen.

Vergelijking van meetintervallen

De waarden in de tabel geven antwoord op verschillende vragen. Vergelijk ze indien mogelijk voor hetzelfde verzoek en noteer de bijbehorende grenzen: een interval dat in de browser zichtbaar is, begint en eindigt niet automatisch op dezelfde punten als een PHP-timer of een NGINX-logwaarde. Daarnaast is het vooral belangrijk dat de Eenheid: Milliseconden en seconden mogen niet zonder controle naast elkaar worden geëvalueerd.

Meetgrootheden en hun respectieve grenzen
Gemeten variabeleBegin en eindeEenheidWachttijden en beperkingen
PHP-code-intervalTussen twee zelfgedefinieerde hrtime-aanroepenNanoseconden als getalswaarde; vaak omgerekend naar millisecondenBevat wachttijden binnen het segment; geen pure CPU-tijd en geen volledige verzoek.
Server-timing-statistiekBepaald door de meetcomponentVoor jou worden milliseconden aanbevolenGeeft een berekende waarde door; de wachttijden die hierin zijn opgenomen, zijn afhankelijk van de gedefinieerde grenzen.
Interval tussen browserverzoekenrequestStart tot responseStartMillisecondenOmvat de wachttijd zoals waargenomen vanuit de browser; responseStart kan een voorlopig antwoord registreren.
Antwoordinterval van de browserresponseStart tot responseEndMillisecondenGeeft het waargenomen antwoordinterval weer; niet gelijkstellen aan de pure PHP-uitvoering.
NGINX-verzoektijdEerste lezing van client-bytes tot het schrijven naar het logboek na het verzenden van de laatste bytesSecondenOmvat het verzoek vanuit het perspectief van NGINX, inclusief wachttijden; de limieten wijken af van die van de PHP-timer.

Controleer het daadwerkelijke logformaat voordat je een waarde interpreteert als de totale duur van de backend. De NGINX-verzoektijd heeft een eigen tijdsbestek: deze begint al bij het lezen van de eerste bytes van de client en loopt door tot het schrijven van het logbestand na het verzenden van de laatste bytes.

Browser- en serverwaarden kunnen worden gebruikt als aanvullende perspectieven, maar mogen niet zonder controle worden opgeteld of van elkaar worden afgetrokken om een volledig tijdsbeeld te krijgen. Meetbereiken kunnen elkaar overlappen, en de klokken van de client en de server zijn niet betrouwbaar gesynchroniseerd. Noteer daarom naast elke waarde welk verzoek en welk antwoordtraject daadwerkelijk zijn waargenomen.

Logs en PHP-FPM aanvullen

Een applicatietimer toont alleen de omkaderde code. Aanvullende Serverlogboeken helpen om hetzelfde verzoek vanuit een ander perspectief te bekijken. Koppel hiervoor de PHP-waarde en het logboekitem aan de hand van een verzoek-ID dat in overeenstemming met de privacywetgeving is toegekend. Controleer eerst of daadwerkelijk hetzelfde antwoordpad is doorlopen en of er geen omleiding wordt verward met een eigen verzoek.

Bij NGINX begint $request_time begint bij het lezen van de eerste client-bytes en eindigt bij het schrijven van het logbestand nadat de laatste antwoord-bytes zijn verzonden. Deze grootte kent andere grenzen dan een timer binnen de PHP-toepassing en is daarom niet daarmee te vergelijken.

Controleer het geconfigureerde logformaat en de meetgrenzen voordat je een logwaarde als PHP-runtime verwerkt. De Analyse van de hostinglatentie voor het netwerk, PHP en de database biedt verdere aanknopingspunten voor het onderzoek naar het gehele antwoordtraject.

Ook het einde van het zichtbare antwoord hoeft niet het einde van het PHP-werk te betekenen. Met fastcgi_finish_request() kan PHP-FPM het antwoord afronden en vervolgens verdere code uitvoeren. Om de belasting van de workers te beoordelen, heb je daarom aanvullende monitoring aan de serverzijde nodig; een korte waarde aan de clientzijde sluit later werk niet uit.

Bij streaming of reeds verzonden headers kan een later vastgestelde totaalwaarde niet meer op betrouwbare wijze in de oorspronkelijke antwoordheader worden opgenomen. Gebruik hiervoor geschikte logbestanden of tracering. Beperk de toegang en bewaring tot het noodzakelijke en vermijd persoonsgegevens of vertrouwelijke inhoud in meetwaarden en correlatie-ID’s.

Database, API en frontend afbakenen

Als het toepassingsinterval lang is, verdeel het dan op functioneel zinvolle punten in kleinere intervallen. Een afzonderlijk gemeten database-oproep kan laten zien hoeveel tijd er binnen deze oproep is verstreken. Vanuit het oogpunt van de toepassing omvat deze waarde eventueel ook verbindings- en overdrachtstijden en is deze niet gelijk te stellen aan de pure rekentijd van de database.

Een lange databasewaarde is een hypothese voor de volgende stap, geen definitieve diagnose. Controleer de betreffende query met de beschikbare database-diagnosetools en het uitvoeringsplan ervan. Pas dan kan worden onderzocht of er bijvoorbeeld sprake is van een ongunstig toegangspad of een andere oorzaak; de PHP-timer alleen is geen bewijs voor een ontbrekende index.

Voor een externe API plaats je nog een timer direct na de uitgaande aanroep. Een lange API-interval laat zien waar de toepassing vastloopt, maar niet automatisch waarom. Onderzoek aan de hand van gedetailleerde client-timings of tracing, voor zover beschikbaar, of er bijvoorbeeld iets opvalt bij het omzetten van namen, het tot stand brengen van de verbinding, de tegenpartij of de gegevensoverdracht.

Als de HTML snel binnenkomt, maar de pagina nog steeds traag lijkt, schakel dan over naar het browserperspectief. Onderzoek de afzonderlijke verzoeken om bronnen en vervolgens de verwerking en weergave van JavaScript. De PHP-timer van het document registreert noch automatisch latere verzoeken om bronnen, noch de volledige werking van de browser; ook voor deze stappen moet je zelf observaties doen.

Als er een PHP-meetwaarde ontbreekt, controleer dan eerst de Cache-pad: Een cache die eerder in het proces is geplaatst, kan een antwoord leveren zonder PHP voor dit verzoek aan te roepen. Het ontbreken van de header betekent daarom niet dat PHP nul milliseconden nodig heeft gehad. Houd cache-treffers en dynamische antwoorden apart bij en vergelijk alleen verzoeken die aan elkaar zijn toegewezen.

Resultaten beoordelen en verder onderzoeken

Voordat je op basis van opvallende cijfers een maatregel neemt, controleer dan of ze wel bij elkaar horen: horen de browsergebeurtenis, de header en het logboek echt bij hetzelfde verzoek? Anders kunnen verschillende gebruikersstatussen, cache-treffers of doorverwijzingen schijnbare verschillen veroorzaken. Documenteer bovendien de grenzen en eenheden van elke waarde voordat je meerdere doorlopen met elkaar vergelijkt.

Op geneste intervallen mag je de deeltijd niet bij de totale tijd optellen. Een verschil tussen de applicatie en de database is evenmin automatisch PHP-CPU-tijd; het geeft in eerste instantie alleen de resterende verstreken tijd binnen de gekozen grenzen weer. Ook is het verschil tussen de meting van de browser en die van de applicatie niet zonder meer louter netwerktijd.

Als het vastgestelde uitvoeringsinterval herhaaldelijk lang is, maar de dure code nog onbekend is, is een profiler de volgende logische stap. Deze kan helpen om het onderzoek te richten op specifieke functies en aanroepspaden. Geef daarbij duidelijk aan welk verzoek en welk gedeelte je profileert, in plaats van het resultaat toe te passen op elke pagina van de applicatie.

Als het daarentegen gaat om het gedrag bij gelijktijdige toegangen, volstaat het niet om slechts één verzoek te meten. Plan een reproduceerbare applicatietest onder goedgekeurde omstandigheden en houd rekening met succesvolle antwoorden, fouten en responstijden. Het artikel over de Benchmarking van server-CPU's voor reële PHP-workloads legt uit hoe een rekenopgave en een toepassingstoets van elkaar kunnen worden onderscheiden.

Houd ten slotte ook rekening met het werk dat na het afronden van het antwoord nog moet worden verricht: bij gebruik van fastcgi_finish_request() kan het snel afsluiten van de browser samenvallen met verdere PHP-bewerkingen. Kies daarom de volgende meting op basis van de open vraag: zichtbare responstijd, duur van een codegedeelte of belasting van de worker zijn verschillende doelstellingen.

Bronnen en stand van zaken op vakgebied

Stand van het onderzoek:

Stand van zaken: 13 november 2026. Het hrtime-voorbeeld vereist PHP 7.3 of hoger; server-timing wordt ingedeeld op basis van het W3C-werkdocument van 2 november 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

Huidige artikelen