...

Mäta PHP-körningstiden separat från nätverket och frontenden

För att skilja mellan PHP-körningstiden i nätverket och i frontenden mäter du först ett tydligt definierat kodintervall med hrtime() och jämför det med webbläsar- och servervärdena för samma begäran. Ett enskilt tidsvärde utgör inte en fullständig tidsbalans: PHP-timern inkluderar även väntetider inom sitt intervall, medan webbläsarens tidsmätningar har andra gränser. Server-timing kan överföra kompletterande värden, men mäter dem inte själv. Du måste ta hänsyn till cache-status, preliminära svar och nästlade mätningar vid jämförelsen.

Vad de aktuella värdena faktiskt visar

En sida som laddas långsamt kan förlora tid på flera ställen: när man väntar på ett svar, i PHP, vid databasfrågor eller senare vid bearbetningen i webbläsaren. Ett enda värde för PHP-körningstid kan inte skilja mellan dessa orsaker. Det avgörande är vilken del av en specifik begäran som ett mätvärde överhuvudtaget avser.

En PHP-timer mäter den tid som förflutit mellan två anrop i applikationskoden. Om ett databas- eller API-anrop sker däremellan räknas även dess väntetid med. Resultatet är därför inte en ren CPU-tid och säger heller ingenting om kod som körs före timerns start eller efter dess slut.

Webbläsaren observerar däremot händelser ur sitt eget perspektiv: till exempel när en förfrågan inleds och när ett svar anländer. Vid en dynamisk dokumentförfrågan kan det mellan dessa händelser förekomma nätverksvägar, proxybehandling och serverarbete. Vilka delar som ingår beror på de respektive händelserna och den faktiska svarsvägen.

HTTP-huvudet Tidtagning för server överförer dessutom angivna värden som till exempel applikationen själv beräknar. Den mäter inte automatiskt hela servervägen. Ett värde för en databasanrop kan dessutom ligga inom applikationens intervall; de båda siffrorna kan då inte läggas samman till en total varaktighet.

Jämför perspektiven för samma begäran, istället för att betrakta dem som en sammanhängande tidsförlopp. Ett långt applikationsintervall är en utgångspunkt för sökningen i backend. Ett kort intervall i kombination med långsam visning i webbläsaren visar däremot inledningsvis bara att orsaken kan ligga utanför just den här specifikt uppmätta kodsektionen.

Fastställa begäran och mätförhållanden

Välj först en specifik rutt och den tillhörande dokumentförfrågan, till exempel en webbutiks dynamiska produktsida. Notera om du undersöker ett inloggat eller anonymt tillstånd och vilka testdata som används. Olika varukorgar, behörigheter eller innehåll kan annars leda till att applikationen inte fungerar på samma sätt.

Definiera sedan Mätgränser: Var i PHP-koden startar timern, var slutar den och vilka databas- eller API-anrop finns däremellan? Notera också om mätningen först börjar efter att ramverket har startat. Endast med dessa uppgifter går det senare att bedöma vad ett kort eller långt värde faktiskt innebär.

Skillnad mellan cacheträffar och cachemissar. Om en uppströms cache levererar svaret utan PHP kan ett applikationsvärde eventuellt saknas; detta är inget bevis på noll millisekunder PHP-bearbetning. Du bör även registrera omdirigeringar som separata förfrågningar, istället för att obemärkt jämföra deras tider med det slutliga dokumentets.

Upprepa testet under så jämförbara förhållanden som möjligt: samma webbläsare, liknande anslutning, samma användartillstånd och dokumenterad cache-status. Ett enskilt test kan avvika på grund av tillfälliga fördröjningar eller en annan svarsväg. Notera därför flera värden och deras förutsättningar, istället för att bara välja det snabbaste värdet.

En AI-genererad symbolbild av två separata, tomma kort och en anteckningsbok på ett skrivbord
AI-genererad illustrativ bild: Villkor som dokumenteras separat underlättar jämförelsen mellan flera förfrågningar.

För övningarna behöver du webbläsarens utvecklingsverktyg och, för en PHP-timer, åtkomst till applikationskoden. Använd en testmiljö eller en godkänd sökväg; produktiva ändringar och belastningstester kräver motsvarande godkännande. Webbserverloggar eller en profilerare kan komplettera analysen, men är inte en förutsättning för varje första jämförelse.

Koppla webbläsarvärdet och mätningen på serversidan till samma begäran, till exempel via en identifierare som hanteras i enlighet med dataskyddsbestämmelserna. Samla inte in onödiga personuppgifter för detta ändamål och begränsa åtkomsten till diagnostisk information. Utan denna koppling kan redan parallella anrop eller en mellanliggande cache-uppdatering förvränga en jämförelse.

Att sätta in webbläsarens tidsangivelser i rätt sammanhang

Öppna nätverksavsnittet i utvecklarverktygen och välj först dokumentförfrågan för den navigering som undersöks. Tidsvärdena för denna begäran beskriver inte automatiskt även bilder, stilmallar eller senare API-anrop. För sådana enskilda resurser ger Resource Timing var för sig en egen bild; deras bearbetning i webbläsaren förklaras därmed inte heller fullständigt.

Tidpunkten requestStart markerar början på förfrågan ur webbläsarens perspektiv. responseStart betecknar början på ett mottaget svar, medan responseEnd markerar slutet på mottagningen av svaret. Skillnaderna beskriver observerade intervall; i synnerhet ska tiden fram till svarets början inte likställas med ett PHP-kodintervall.

Med preliminära svar krävs särskild försiktighet: Ett svar som ”103 Early Hints” kan redan vid responseStart ska beaktas. När webbläsaren finalResponseHeadersStart stöder detta, hjälper denna tidpunkt oss att se början på det slutgiltiga svaret. Skillnaden jämfört med requestStart får därför inte generellt betecknas som väntetid fram till den slutgiltiga HTML-huvudet.

Cache, service worker, omdirigeringar och återanvända anslutningar påverkar vilken väg en begäran tar och hur dess tidsvärden ska tolkas. För resurser från andra ursprung kan vissa uppgifter saknas eller vara noll om de inte har godkänts på rätt sätt. Kontrollera dessa förutsättningar innan du jämför två webbläsarvärden med varandra.

Om väntetiden i webbläsaren är lång, men det uppmätta PHP-intervallet är kort, innebär det inte nödvändigtvis att det finns ett nätverksproblem. Tid kan också gå förlorad i en proxy eller i en kö före PHP-mätpunkten. Jämförelsen kräver särskild försiktighet om PHP-bearbetningen först sker efter ett preliminärt svar: de båda intervallen har då olika gränser.

Mäta PHP-kod med hrtime

Med hrtime(true) mäter du den tid som förflutit mellan två valfria punkter i PHP-koden. Funktionen använder en monoton tidsbas: Under denna tidsperiod beräknar du skillnaden mellan två anrop, istället för att tolka en tidpunkt som klockslag. Det uppmätta intervallet kan även innehålla väntetider och är därför inte ren CPU-tid.

Skapa en isolerad testfil för följande exempel i en delad miljö med PHP 7.3 eller senare. Öppna den via webbservern så att du sedan kan kontrollera svarshuvudet i webbläsarens utvecklingsverktyg. Platshållaren står för den del av applikationen vars början och slut du själv bestämmer.

Kod
<?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;

Funktionen returnerar ett talvärde i nanosekunder; genom att dividera med en miljon får man varaktigheten i millisekunder. På 32-bitars system kan returvärdet vara ett flyttal. Felkontrollen förhindrar att vid ett returvärde på false en ogiltig varaktighet anges. Enheten nanosekunder garanterar i sig inte någon motsvarande mätnoggrannhet.

I exemplet slutar intervallet innan rubriken sätts och innan utmatningen. Det omfattar därför varken dessa steg eller arbete som utförs före den första eller efter den andra tidsstämpeln. Om du sätter starttiden först efter att ramverket har startat, utelämnas även dess tidigare initialisering i resultatet.

Om du ersätter platshållaren med ett databas- eller API-anrop räknas dess väntetid in i intervallet. Ett högt värde visar alltså inledningsvis att det inramade avsnittet tog lång tid; det skiljer ännu inte mellan PHP-beräkningar och väntetid på andra tjänster. För att kunna göra denna åtskillnad behöver du ytterligare, tätare placerade mätpunkter.

Överför mätvärden via Server-Timing

Rubriken Server-Timing överför utvalda mätvärden till klienten. Den mäter inte själva varaktigheten: applikationen eller en inblandad serverkomponent måste först beräkna värdet. För dur rekommenderar att man anger millisekunder; namnet beskriver måttet, men inte automatiskt dess mätgränser.

I PHP-exemplet måste rubriken placeras före den utdata som faktiskt skickas. Den andra parametern false med header() lägger till ytterligare ett headerfält istället för att ersätta ett befintligt fält med samma namn. I ett ramverk är en response-middleware ofta en lämplig integrationspunkt, förutsatt att mätningen redan är avslutad där och att headrarna ännu inte har skickats.

Följande HTTP-svarhuvud visar två fiktiva värden; det är inte en mätning. Om vi antar att databasintervallet helt och hållet ligger inom applikationsintervallet, är värdena nästlad. De 75 millisekunderna för databasen ingår redan i de 120 millisekunderna för applikationen och får inte läggas till.

En AI-genererad illustration av ett delintervall som helt och hållet ingår i ett större tidsintervall
AI-genererad illustration: Ett intervall som ingår i databasen läggs inte till i applikationens varaktighet.
Kod
Server-Timing: app;dur=120.000, db;dur=75.000

Skillnaden på 45 millisekunder beskriver, enligt detta antagande, endast den återstående tiden inom app. Det är inte automatiskt PHP-processortid: även där kan andra väntetider ingå. Dokumentera därför för varje mätvärde var det börjar och slutar och om det omfattar andra intervall.

Ange endast noggrant utvalda, tillräckligt grova värden. Metriknamn och beskrivningar kan avslöja detaljer om infrastrukturen; personuppgifter hör inte hemma i rubriken. Åtkomst till tidsdata från olika källor via JavaScript är begränsad och kan hanteras med Timing-Allow-Origin styras. Du bör noggrant kontrollera om ett sådant godkännande krävs för de aktuella ursprungen.

Jämförelse av mätintervall

Värdena i tabellen ger svar på olika frågor. Jämför dem om möjligt för samma begäran och notera respektive gränsvärden: Ett intervall som syns i webbläsaren börjar och slutar inte automatiskt på samma ställen som en PHP-timer eller ett NGINX-loggvärde. Det är dessutom särskilt viktigt att Enhet: Millisekunder och sekunder får inte utvärderas sida vid sida utan att först kontrolleras.

Mätvärden och deras respektive gränser
Mätt variabelBörjan och slutetEnhetVäntetider och begränsningar
PHP-kodintervallMellan två självvald hrtime-anropNanosekunder som siffervärde; omräknas ofta till millisekunderInnehåller väntetider inom avsnittet; varken ren CPU-tid eller en fullständig begäran.
Mätvärde för servertimingBestäms av mätkomponentenFör dig rekommenderas millisekunderÖverför ett beräknat värde; de väntetider som ingår beror på de definierade gränserna.
Intervall för webbläsarförfrågningarfrån requestStart till responseStartMillisekunderOmfattar den väntetid som observerats ur webbläsarens perspektiv; responseStart kan registrera ett preliminärt svar.
Webbläsarens svarstidresponseStart till responseEndMillisekunderBeskriver det observerade svarstidsintervallet; ska inte likställas med ren PHP-körning.
NGINX-förfrågningstidFörsta läsningen av klientbytes fram till att loggen skrivs efter att de sista bytena har skickatsSekunderOmfattar begäran ur NGINX:s perspektiv, inklusive väntetider; gränserna skiljer sig från PHP-timern.

Kontrollera det faktiska loggformatet innan du tolkar ett värde som varaktigheten för hela backend-processen. NGINX:s begärandetid har sin egen tidsram: den börjar redan när de första klientbytena läses in och sträcker sig fram till att loggen skrivs efter att de sista bytena har skickats.

Värden från webbläsare och servrar kan användas som kompletterande perspektiv, men får inte utan kontroll läggas ihop eller dras ifrån varandra för att skapa en fullständig tidsöversikt. Mätområdena kan överlappa varandra, och klient- och serverklockorna är inte tillförlitligt synkroniserade. Notera därför vid varje värde vilken begäran och vilken svarsväg som faktiskt har observerats.

Komplettera loggar och PHP-FPM

En applikationstimer visar endast den inramade koden. Kompletterande Serverloggar hjälper dig att betrakta samma begäran ur ett annat perspektiv. För att göra detta ska du koppla ihop PHP-värdet och loggposten med hjälp av en begäran-ID som tilldelats i enlighet med dataskyddsbestämmelserna. Kontrollera först om det verkligen är samma svarsväg som har genomgåtts och att ingen vidarebefordran förväxlas med en egen begäran.

Med NGINX börjar $request_time den börjar när de första klientbyten läses in och slutar när loggen skrivs ut efter att de sista svarsbyten har skickats. Denna storlek har andra gränser än en timer inom PHP-applikationen och kan därför inte likställas med den.

Kontrollera det konfigurerade loggformatet och mätgränserna innan du behandlar ett loggvärde som en PHP-körning. Den Analys av latens vid webbhotell för nätverk, PHP och databaser ger ytterligare utgångspunkter för en undersökning av hela svarsvägen.

Även om det synliga svaret tar slut behöver det inte betyda att arbetet med PHP är avslutat. Med fastcgi_finish_request() kan PHP-FPM slutföra svaret och därefter köra ytterligare kod. För att bedöma belastningen på arbetarna behöver du därför även övervakning på serversidan; ett kortvarigt värde på klientsidan utesluter inte att ytterligare arbete krävs senare.

Vid strömning eller redan sända rubriker går det inte längre att på ett tillförlitligt sätt infoga ett sammanlagt värde som fastställts i efterhand i den ursprungliga svarsrubriken. Använd lämpliga loggar eller spårning för detta ändamål. Begränsa åtkomst och lagring till det nödvändiga och undvik personuppgifter eller konfidentiellt innehåll i mätvärden och korrelationsidentifierare.

Begränsa databasen, API:et och frontenden

Om applikationsintervallet är långt ska du dela upp det i mindre intervall på platser där det är meningsfullt ur ett tekniskt perspektiv. En separat mätt databasåtkomst kan visa hur mycket tid som förflutit inom denna åtkomst. Ur applikationssynpunkt kan värdet i förekommande fall även omfatta anslutnings- och överföringstider och ska inte likställas med databasens rena beräkningstid.

Ett långt databasvärde är en hypotes inför nästa steg, inte en färdig diagnos. Kontrollera den berörda frågan med hjälp av tillgängliga databasdiagnosverktyg och dess exekveringsplan. Först då går det att undersöka om det till exempel rör sig om en ogynnsam åtkomstväg eller någon annan orsak; PHP-timern i sig är inte ett bevis på att ett index saknas.

För ett externt API sätter du en ytterligare timer direkt efter det utgående anropet. En lång API-intervall visar var applikationen väntar, men inte automatiskt varför. Undersök med hjälp av detaljerade klienttidtagningar eller spårning, i den mån sådana finns tillgängliga, om till exempel namnupplösning, uppkoppling, motparten eller överföringen uppvisar något onormalt.

Om HTML-koden laddas snabbt men sidan fortfarande känns långsam, byt till webbläsarvyn. Granska de enskilda resursförfrågningarna och därefter JavaScript-bearbetningen och visningen. Dokumentets PHP-timer registrerar varken senare resursförfrågningar automatiskt eller webbläsarens hela arbete; även för dessa steg behöver du göra egna observationer.

Om ett PHP-mätvärde saknas, kontrollera först Cache sökväg: En cache i förväg kan leverera ett svar utan att PHP behöver anropas för den här begäran. Att rubriken saknas betyder därför inte att PHP har tagit noll millisekunder. Registrera cacheträffar och dynamiska svar separat och jämför endast begäranden som är korrekt kopplade till varandra.

Utvärdera och granska resultaten ytterligare

Innan du drar slutsatser utifrån iögonfallande siffror bör du kontrollera deras tillhörighet: Tillhör webbläsarhändelsen, rubriken och loggen verkligen samma förfrågan? Olika användartillstånd, cacheträffar eller omdirigeringar kan annars skapa skenbara skillnader. Dokumentera dessutom gränserna och enheterna för varje värde innan du jämför flera genomgångar.

Med nästlade intervall får du inte lägga till deltidsvärdet till den totala tiden. En skillnad mellan applikationen och databasen är inte heller automatiskt PHP-CPU-tid; den beskriver i första hand endast den återstående förflutna tiden inom de valda gränserna. På samma sätt är skillnaden mellan webbläsarens och applikationens mätningar inte automatiskt ren nätverkstid.

Om det definierade applikationsintervallet är upprepade gånger långt, men den kostsamma koden fortfarande är okänd, är en profilerare nästa rimliga steg. Den kan hjälpa till att rikta undersökningen mot specifika funktioner och anropspår. Ange tydligt vilken begäran och vilket avsnitt du profilerar, istället för att tillämpa resultatet på varje sida i applikationen.

När det däremot gäller beteendet vid samtidiga åtkomstförsök räcker det inte med att mäta en enskild förfrågan. Planera ett reproducerbart applikationstest under godkända förhållanden och ta hänsyn till framgångsrika svar, fel och svarstider. Artikeln om Prestandatester av server-CPU:er för verkliga PHP-arbetsbelastningar förklarar hur man kan skilja mellan en räkneuppgift och ett tillämpningstest.

Beakta slutligen även arbetet efter att svaret har färdigställts i bedömningen: Vid användning av fastcgi_finish_request() En snabb avslutning av webbläsaren kan sammanfalla med ytterligare PHP-bearbetning. Välj därför nästa mätning utifrån den aktuella frågan: synlig svarstid, varaktighet för en kodsektion eller belastning på arbetaren är olika mål.

Källor och aktuell kunskapsnivå

Forskningsläget:

Sista uppdatering: 13 november 2026. Exemplet med hrtime kräver PHP 7.3 eller senare; Server-Timing klassificeras enligt W3C:s arbetsutkast från den 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

Aktuella artiklar