...

Server-Timing-huvudet: Att förstå backend-körtider i webbläsaren

Der Server-Timing-rubrik överförar självinsamlade backend-nyckeltal via ett HTTP-svar. Du kan koppla dem till respektive förfrågan i webbläsarens DevTools eller läsa av dem via Performance API. Förutsättningen är att applikationen eller någon annan svarande komponent samlar in och skickar ut värdena. Huvudet är ingen automatisk profilerare: Endast dokumenterade mätgränser visar vilken arbetsinsats en varaktighet omfattar. Överlappningar, nätverksvägar och cache-svar kan påverka tolkningen.

Vad Server-Timing visar

En långsam sida kan förlora tid i webbläsaren, under nätverksöverföringen eller vid bearbetningen på servern. Den Server-Timing-rubrik förenar dessa synsätt: Den överför nyckeltal som en involverad serverkomponent själv har registrerat tillsammans med ett HTTP-svar. Webbläsaren kan sedan koppla dem till respektive förfrågan och visa dem.

För detta måste till exempel applikationen mäta varaktigheten för en databasoperation och skriva in värdet i svarshuvudet. Även en proxy eller någon annan komponent som skickar svar kan bidra med mätvärden. Utan en sådan instrumentering kan webbläsaren inte i efterhand fastställa hur lång tid enskilda steg på serversidan har tagit.

Rubriken är alltså en Transportformat, ingen automatisk profilerare. Den bestämmer inte vilka interna funktioner som ska undersökas eller hur detaljerat en applikation måste mäta. Vilka nyckeltal som visas beror på vad den ansvariga komponenten registrerar och släpper vidare för visning.

För Backend-prestanda Det är till hjälp eftersom ett självmätt avsnitt visas direkt bredvid informationen om webbläsarförfrågan. Ett högt värde är i första hand en utgångspunkt för vidare undersökningar, men ännu inget bevis på varför en sida är långsam. Nyckeltalet i sig förklarar varken orsaken eller alla andra faktorer som påverkar webbprestandan.

För praktisk användning behöver du därför tillgång till applikationen eller någon annan komponent som kan påverka svaret. Om mätvärden redan tillhandahålls kan du däremot granska dem i webbläsaren utan att själv behöva ändra serverkonfigurationen. Även i så fall bör du ta reda på varifrån värdena kommer och vad de faktiskt omfattar.

Att förstå mätvärden och rubriksyntax

Ett HTTP-svar kan innehålla en eller flera Server-Timing-rubrikrader. Inom en rad avgränsas de enskilda mätvärdena med kommatecken; varje parameter inleds med ett semikolon. Varje mätvärde måste ha ett namn, medan varaktighet och beskrivning är valfria. En rapporterad varaktighet anges i parametern dur och anges i millisekunder.

Följande exempel visar en HTTP-svarsrubrik med två mätvärden. Siffrorna är valda godtyckligt och utgör inga mätningar; raden är endast ett syntaxexempel och förutsätter ingen specifik applikation eller serverkonfiguration.

Kod
Server-Timing: db;dur=42.5;desc="Datenbank", render;dur=18.0

Här avses db en mätvärde med varaktighet och beskrivning; render har en varaktighet, men ingen beskrivning. Uppgifterna enligt desc Dessa uppgifter är avsedda som förklaring. De ersätter inte dokumentationen om när respektive mätning börjar och slutar.

Komponenter i ett mått på servertiming
BeståndsdelBetydelseObligatorisk statusExempel
NamnAnger metrikenKrävsdb
durVaraktighet i millisekunderValfrittdur=42,5
descBeskrivning av måttetValfrittdesc="Databas"

Ett namn som db avslöjar i sig inte heller Mätgränser eller mätmetoden. Det kan avse en enskild sökning, flera sammanräknade sökningar eller en annorlunda definierad del av databasen. Först när dokumentationen av instrumenteringen finns tillgänglig blir det tydligt vilket arbete som faktiskt ingår i värdet.

För att kunna göra meningsfulla jämförelser bör du därför för varje mått ange start- och slutpunkt samt beskriva om det omfattar ytterligare deloperationer. Om till exempel namnet förblir detsamma, medan applikationen senare räknar in ytterligare sökningar i tidsberäkningen, är gamla och nya värden inte direkt jämförbara. Syntaxen i sig själv ger ingen indikation på en sådan förändring.

Skillnaden mellan backend-tid och väntetid i webbläsaren

Den väntetid som visas i webbläsaren och den rapporterade backend-tiden avser inte nödvändigtvis samma tidsperiod. En mätvärde kan endast omfatta en medvetet vald del av bearbetningen, medan webbläsarvyn visar ytterligare delar av förfrågnings- och svarsvägen. Liknande eller olika siffror innebär därför inte automatiskt att de båda mätningarna bekräftar eller motsäger varandra.

Mellan webbläsaren och applikationen kan det till exempel finnas nätverksvägar och proxyservrar. Även köer eller arbetssteg inom backend-systemet kan eventuellt ligga utanför de fastställda mätpunkterna. Om webbläsaren väntar längre än vad en rapporterad databasoperation tar, går det därför inte att enbart utifrån detta enda mått hänföra skillnaden till en specifik orsak.

Omvänt kan server-timing-mått överlappa eller vara inbäddade i varandra. Om en totalmätning mäter bearbetningen av en förfrågan, inklusive databasoperationen, ingår dess varaktighet redan i det totala värdet. Om du lägger ihop båda siffrorna räknar du denna del två gånger; vid parallellt utförda operationer kan summan av deras enskilda varaktigheter också vara större än den förflutna tiden.

Rubriken utgör därför inte automatiskt en fullständig Vattenfall bearbetningen. Den överför utvalda nyckeltal, men namnen och varaktigheterna i sig anger varken någon tidsmässig ordning eller några samband mellan avsnitten. För att kunna tolka uppgifterna måste du veta om instrumenteringen registrerar separata, överlappande eller samtidigt pågående arbeten.

Innan du drar slutsatser om en optimering bör du fastställa mätgränserna och villkoren för den aktuella förfrågan. Upprepa därefter liknande förfrågningar och kontrollera om mönstret upprepas under samma förhållanden. På så sätt kan du bättre skilja ett enstaka avvikande värde från en återkommande indikation, utan att dra slutsatser om orsaken enbart utifrån mätvärdet.

Kontrollera HTML-svaret i DevTools

För en dynamisk HTML-sida kan applikationen registrera två separata steg: en databasoperation och den efterföljande genereringen av HTML-koden. Mätningen måste konfigureras i applikationen eller i någon annan komponent som skickar svaret. DevTools visar de värden som levereras, men beräknar inte själv de interna körtiderna.

Definiera för db början, omedelbart före anropet av en viss databasoperation, och slutet, så snart resultatet av denna finns tillgängligt i applikationen. För render Tiden börjar räknas omedelbart före skapandet av HTML-koden och slutar så snart den färdiga HTML-koden för svaret är klar. Dokumentera om exempelvis inläsningen av mallar ingår i detta.

Om båda stegen är avslutade innan svarsrubrikerna skickas: Då skulle svaret kunna Server-Timing: db;dur=42.5, render;dur=18.0 ingår. Siffrorna är godtyckligt valda och utgör ingen mätning. Det är först de dokumenterade start- och slutpunkterna som gör dem meningsfullt jämförbara för en senare analys.

Öppna utvecklarverktygen i Chrome och gå till fliken ”Nätverk”. Ladda om sidan, välj dokumentförfrågan i förfrågningslistan och kontrollera den mottagna råhuvudet under ”Huvuden”. Under ”Timing” kan du sedan se de rapporterade värdena för servertiming; den exakta visningen kan variera beroende på webbläsare.

En iögonfallande Individuellt värde är en utgångspunkt, inte ett bevis på en allmän orsak. Upprepa liknande förfrågningar och notera till exempel vilken sida som används, cache-status och ändringar i applikationen. På så sätt kan du bättre se om ett mönster upprepas eller om ett enskilt svar avviker från det normala.

Läs API-tider utan dubbelräkning

I en API kan applikationen, förutom hela bearbetningen, även hantera väntetiden på en extern tjänst. Avgörande här är Mätgräns: Om den totala tiden börjar när API-hanteraren aktiveras och slutar när dess svar är klart för utmatning, kan det externa anropet helt och hållet ingå i den.

I följande fritt valda exempel börjar den externa varaktigheten omedelbart innan förfrågan skickas till tjänsten och slutar så snart svaret från tjänsten finns tillgängligt i applikationen. Värdena används endast för beräkningen och utgör inte någon mätning. Tabellen beskriver uttryckligen överlappande tidsperioder, inte två oberoende arbetspaket.

Ett godtyckligt exempel på nästlade API-mått
MätetalMätgränser i exempletVaraktighet
Total bearbetningGå in i Handler tills svaret är klart120 ms
Externt anropSkicka förfrågan tills tjänsten har svarat80 ms

Beräkningen 120 ms plus 80 ms ger visserligen 200 ms, men skulle här vara en Dubbelräkning: De 80 ms ligger redan inom de 120 ms. Räknat matematiskt återstår 40 ms av den totala tidsperioden utanför det externa anropet. Rubriken i sig förklarar dock inte vilken aktivitet eller väntetid som ingår i denna återstående tidsperiod.

En AI-genererad illustration av en mindre cirkel inom en större, som en symbol för inbäddade API-tider
AI-genererad illustration: Tiden för ett externt anrop kan redan ingå i den totala bearbetningstiden.

Inte heller parallella beroenden kan enkelt summeras till en total förfluten tid. Om till exempel två anrop körs samtidigt och var och en tar 80 ms, summeras deras enskilda varaktigheter till 160 ms, även om deras tidsperioder i stor utsträckning kan överlappa varandra. Utan information om start- och sluttidpunkt går det inte att bestämma den faktiska graden av överlappning enbart utifrån varaktigheterna.

För att avgöra vilken tjänst som utlöste nästa anrop kompletterar distribuerad spårning header-värdena. Server-Timing kan koppla utvalda tidsvärden till webbläsarens svar, men beskriver inte i sig de fullständiga orsakssambanden mellan tjänsterna. Se till vid jämförelsen att spårningen och rubrikvärdena avser samma operationer och gränser.

Läsa av servertid med JavaScript

Die Performance API gör befintliga server-timing-data tillgängliga även programmatiskt. En navigationspost beskriver inläsningen av det aktuella dokumentet; dess egenskap serverTiming innehåller de rapporterade mätvärden som finns tillgängliga för detta. Det är ett annat urval än en post för en efterladdad resurs eller ett API-anrop.

Kör följande JavaScript-kod i webbläsarkonsolen på den sida som ska undersökas. Den väljer den första tillgängliga navigeringsposten och visar dess lista över servertider i tabellform. Koden läser endast redan tillgängliga värden: den ändrar inte serverkonfigurationen och utför ingen belastningstest.

Kod
const navigation = performance.getEntriesByType("navigation")[0];
console.table(navigation?.serverTiming ?? []);

Om det inte finns någon navigeringspost eller om den inte tillhandahåller tillgängliga mätvärden visar exemplet en tom lista. Detta innebär varken att sidan är snabb eller långsam, och inte heller nödvändigtvis att servern saknar mätverktyg. Kontrollera först svarhuvudet och se om den valda posten verkligen beskriver den önskade förfrågan.

För en återladdad resurs behöver du istället den rätta Resurspost. Bland posterna av typen resource kan du utifrån namnet identifiera den sökta förfrågan och dess serverTiming-Granska egenskapen. Om du anropar samma adress flera gånger måste du vara uppmärksam på vilken specifik post du jämför.

När det gäller resurser som sträcker sig över flera ursprung påverkar dessutom rätt godkännande via Timing-Allow-Origin om Performance API gör tidsinformationen tillgänglig. Även webbläsarstöd och den aktuella miljön kan påverka resultatet. Jämför därför en tom lista med råhuvudet innan du gör ändringar i applikationen.

Origin-delningar och känslig information

Vid åtkomst via Performance API är ursprunget för den anropande sidan avgörande. Om en resurs härstammar från ett annat ursprung måste dess svar innehålla Timing-Allow-Origin att bevilja lämplig åtkomst till den anropande ursprungskällan, så att JavaScript kan läsa av relevant tidsinformation, inklusive server-timing. En CORS-behörighet i sig ersätter inte denna ytterligare behörighet.

En konkreta ursprung begränsar åtkomsten till den angivna källan. Platshållaren * Däremot tillåter det i princip alla Origins att se den aktuella tidsinformationen via Performance API. Välj därför den mer begränsade behörigheten om endast en känd applikation behöver värdena, och kontrollera dem mot det faktiska resurssvaret.

Origin-fältet gör inte en svarsheader konfidentiell. Den som tar emot HTTP-svaret kan i princip granska dess innehåll. Publicera därför varken inloggningsuppgifter, personuppgifter eller interna värdnamn i metriknamn och beskrivningar. Även detaljerade körningstider kan ge ledtrådar till interna processer; redovisa endast värden där du medvetet har vägt nyttan mot risken.

Kontrollera dessutom utvärderingen i de webbläsare som din applikation ska stödja: Stödet för enskilda detaljer och kraven på säkra sammanhang kan variera. För att säkerställa svaren i allmänhet krävs dessutom lämpliga säkerhetsrubriker för webbservrar relevanta; de ersätter dock varken granskningen av tidpunkten för offentliggörandet eller beslutet om vilka mätvärden som får offentliggöras.

Kontrollera saknade värden och cache-effekter

Om listan med server-timing-värden är tom, börja med den specifika förfrågan i nätverksdelen av DevTools. Kontrollera under ”Headers” om det levererade svaret överhuvudtaget innehåller en Server-Timing-Header och vilka namn som finns där. Om den saknas, undersök instrumenteringen och eventuella förändringar orsakade av mellanliggande komponenter, istället för att dra slutsatser om hastigheten utifrån den tomma listan.

Om råhuvudet finns, kontrollera sedan Prestanda-post: Navigationsposten beskriver hur dokumentet laddas, medan ett API-anrop eller en annan resurs kräver en motsvarande resurspost. För resurser som sträcker sig över flera domäner kontrollerar du dessutom behörigheten genom Timing-Allow-Origin samt stödet i den webbläsare som används. En tom lista bevisar i sig varken bristande instrumentering eller ett snabbt eller långsamt svar.

Även ett befintligt värde behöver sättas in i sitt sammanhang. Ett CDN eller en proxy kan bidra med egna mätvärden; samtidigt kan ett svar, inklusive rubriker, komma från en cache. Då beskriver ett tidigare genererat origin-mätvärde inte nödvändigtvis origin-serverns arbete för den aktuella förfrågan. Dokumentera därför Cache-status och ursprung oberoende av varaktigheten.

AI-genererad symbolbild av en ansluten nätverkskabel till en switch, i en närbild från sidan
AI-genererad illustrativ bild: Det kan finnas ytterligare nätverkskomponenter mellan webbläsaren och applikationen.

Kontrollera i den konkreta arkitekturen vilken komponent som sätter, vidarebefordrar eller ändrar rubriken och hur den hanterar cachade svar. Jämför därefter förfrågningar med känt cache-tillstånd, i den mån din infrastruktur tillåter det. Skillnader mellan dessa svar är användbara ledtrådar, men utan kunskap om respektive mätgränser är de ännu inget bevis för en specifik orsak.

Loggar, trailrar och val av verktyg

Server-Timing kompletterar andra diagnostiska metoder istället för att ersätta dem. Vilket alternativ som är lämpligt beror på om du vill förstå en enskild webbläsarförfrågan, programmatiskt samla in befintliga värden eller undersöka samband mellan flera tjänster. I följande översikt redogörs för vilka insikter respektive metod ger, samt dess förutsättningar och begränsningar.

Jämförelse av diagnostiska metoder för HTTP-svar
VerktygInsiktFörkunskapskravGräns
DevToolsKontrollera enskilda förfrågningar och angivna tiderWebbläsarförfrågan med relevanta mätvärdenIngen automatisk orsaksanalys
Performance APILäsa av befintliga tidsvärden med JavaScriptMotsvarande post och, i förekommande fall, godkännande av ursprungIngen fullständig tjänsteövergripande process
ServerloggarAnalysera tider som loggats på serversidanLämpligt loggformat och åtkomst till loggarMätgränser och enheter måste kontrolleras
Distribuerad spårningUndersöka sambanden mellan de berörda tjänsternaInstrumentering och tilldelning av spårExtra kostnader för drift och instrumentering

För ett nyckeltal som först fastställs efter att svaret har skickats kan en loggpost vara lämpligare än en vanlig svarhuvudrad. NGINX loggar till exempel request_time och upstream_response_time i sekunder med upplösning i millisekunder. Server-Timing använder däremot millisekunder: ett värde i sekunder måste multipliceras med 1 000. Innan du gör en jämförelse bör du dessutom kontrollera när respektive mätning börjar och slutar.

På Streaming Det kan hända att den totala längden på svarsdelen ännu inte är fastställd när vanliga rubriker skickas. Specifikationen tillåter även Server-Timing som HTTP-trailer. Detta är dock ingen universell lösning: Fetch API ger inte tillgång till trailrar, och hur de visas i utvecklingsverktyg måste kontrolleras separat för varje enskild webbläsare.

För mer tillförlitliga jämförelser upprepar du likartade förfrågningar under dokumenterade förhållanden: Notera till exempel slutpunkt, cache-status och relevanta ändringar i systemet. Betrakta flera värden istället för en enskild förfrågan och undersök påfallande skillnader ytterligare med hjälp av loggar eller spårningar. På så sätt blir det tydligt vilken observation som faktiskt täcks av vilken mätning.

En webbläsarbaserad testmiljö kan vara till hjälp när man provar olika inställningar för applikationer, men återspeglar inte automatiskt de nätverksvägar och servertjänster som kommer att användas i den framtida driften. Detta gäller även för WordPress Playground i webbläsaren. Du bör dessutom testa påståenden om en specifik hosting- och backend-konfiguration i en miljö som så långt som möjligt liknar produktionsmiljön.

Källor och aktuell kunskapsnivå

Forskningsläget:

Uppgifterna är aktuella per den 13 november 2026. Visningen i webbläsaren och stödet för enskilda funktioner kan variera; exemplen innehåller inga egna mätningar.

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/

Aktuella artiklar

AI-genererad illustration av ett svarsformulär med flik på sidan och geometriska markeringar för medföljande nyckeltal
Plesk-webbserver

Server-Timing-huvudet: Att förstå backend-körtider i webbläsaren

Server-Timing-headern visar egeninsamlade backend-mätvärden i webbläsarens utvecklingsverktyg. Lär dig hur du kontrollerar mätgränser, läser av värden med JavaScript och tolkar cache- och origin-effekter på rätt sätt.