{"canonical_url":"https://engineer.company/sv/glossary/observability/","content_markdown":"# Observerbarhet\n\n## Vad det är\n\nObserverbarhet är i vilken grad ett team kan förstå vad ett körande system gör\nutifrån, enbart med hjälp av de data som systemet självt skickar ut, utan att\nöppna det och utan att i förväg veta vad som har gått fel.\nOpenTelemetry-projektets introduktion beskriver det med frågor: ett observerbart\nsystem låter dig ställa frågor om det utan att känna till hur det fungerar inuti,\näven frågor som ingen tänkte på när koden skrevs. Introduktionen sammanfattar frågan som\nsystemet ska kunna besvara som ”Varför händer det här?”\n\nDärmed är observerbarhet en egenskap hos systemet, inte en produkt. Ett verktyg\nkan lagra och visa data, men data måste först komma från applikationen.\nOpenTelemetrys dokumentation säger det rakt ut: för att ett system ska vara\nobserverbart måste dess komponenter vara instrumenterade, alltså måste deras kod\nskicka ut signaler. Dokumentationen sätter också en praktisk ribba. En\napplikation är ordentligt instrumenterad när utvecklarna inte behöver lägga till\nmer instrumentering för att felsöka ett problem, eftersom informationen redan\nfinns där.\n\nDessa data kallas telemetri, och OpenTelemetry delar in dem i signaler:\n\n- **Spår** (traces) visar vägen som en enskild begäran tar genom systemet. Ett\n  spår består av span, där varje span är en arbetsenhet med ett namn, en start-\n  och sluttid och attribut som HTTP-metoden och routen. Det första spannet är\n  roten och täcker begäran från början till slut.\n- **Mätvärden** (metrics) är mätningar som görs medan systemet kör och som\n  aggregeras över tid: felfrekvens, antal begäranden per tidsenhet, processoranvändning.\n- **Loggar** är tidsstämplade poster om händelser. Många av dem hör inte till\n  någon särskild begäran.\n- **Baggage** är kontextuppgifter som skickas med en begäran så att andra\n  signaler kan använda dem.\n\nSignalsidan tar också upp events, en särskild typ av logg, och profiler, som\nregistrerar resursanvändning på kodnivå, som signaler under utveckling eller på\nförslagsstadiet.\n\nDet som förvandlar tre högar med data till något ett team kan ställa frågor\ntill är sammankoppling. OpenTelemetry skickar kontext vidare mellan tjänster, så\natt ett span i en tjänst vet vilket spår det hör till, och det kan stämpla id:na\nför det aktiva spåret och spannet på varje loggpost. Varje signal bär också en\nresurs: attribut som identifierar det som producerade signalen, till exempel\ntjänstens namn, värden eller containern. Med de gemensamma nycklarna kan ett\nteam gå från ett mätvärde till begärandena bakom det, och från en begäran till\nloggraderna den lämnade efter sig.\n\nObserverbarhet och övervakning överlappar, men de är inte samma sak. Övervakning\nhåller utkik efter förhållanden som någon i förväg har bestämt sig för att bry\nsig om och slår larm när ett av dem inträffar. Observerbarhet är det teamet har\natt arbeta med när larmet har gått och orsaken är något som ingen hade räknat\nmed.\n\n## Varför det spelar roll\n\nModerna system fallerar på sätt som är svåra att förutse. En begäran kan passera\nen gateway, flera tjänster, en kö och en databas innan den får svar, och ett fel\ni vilken som helst av dem kan visa sig som långsamhet någon helt annanstans.\nIntroduktionen kallar distribuerad spårning nödvändig för sådana system, eftersom\nderas problem ofta är icke-deterministiska eller för komplicerade för att\nåterskapas på en utvecklares egen dator. När ett fel inte går att återskapa är\ntelemetrin som spelades in medan det hände det enda bevis som finns.\n\nDashboards och larm besvarar frågor som någon har förutsett. Det är värdefullt,\noch det täcker de fel som teamet har sett förut. De svåra incidenterna är de\nnya, där frågan inte är om felfrekvensen steg, utan varför begäranden från en\nregion, genom en version, till en betalleverantör började misslyckas. Om svaret\nkräver att någon skriver ny kod, driftsätter den och väntar på att problemet ska\nkomma tillbaka, varar avbrottet lika länge som den omvägen.\n\nObserverbarhet håller också användaren i centrum. Introduktionen definierar\ntillförlitlighet som frågan om tjänsten gör det användarna förväntar sig, och\nger ett exempel: en webbutik kan vara uppe hela tiden och ändå vara opålitlig om\nett klick för att lägga svarta skor i varukorgen inte alltid lägger svarta skor\ni varukorgen. Det skulle en mätning på servernivå aldrig visa. Telemetri från\nenskilda begäranden kan det, och det är den som servicenivåindikatorer byggs av:\nmätningar sedda från användarens sida, som servicenivåmål sedan knyter till det\nverksamheten behöver.\n\nTill sist förändrar det vad en incident kostar. Ett team som kan följa en\nlångsam begäran till exakt det anrop som höll upp den lägger tiden på att rätta\ni stället för att gissa, och postmortem efteråt kan hänvisa till bevis i stället\nför minnesbilder.\n\n## Så ser det ut i praktiken\n\nTänk dig en påhittad webbutik. Sedan klockan 14 tar en liten andel av köpen mer\nän två sekunder i kassan. Ingenting ligger nere, inget larm har gått och det\nfinns ingen dashboard för just det här. Så här skulle ett team med\nsammankopplade signaler gå till väga. Alla namn, id:n och siffror nedan är\npåhittade för exemplets skull.\n\nFörsta steget är histogrammet över hur lång tid kassan tar, mätt i sekunder. I\ntextformatet för OpenMetrics kan en bucket bära ett exemplar efter ett `#`: en\nhänvisning till data utanför mätvärdet, oftast id:t för ett spår som hamnade i\nden bucketen. Två av bucketarna ser ut så här:\n\n```text\ncheckout_bucket{le=\"1.0\"} 95\ncheckout_bucket{le=\"2.5\"} 97 # {trace_id=\"3f1c9a77e2b04d18a6c5e0b9d4127f60\"} 2.3\n```\n\nAndra steget följer det spår-id:t. Spåret visar vart de 2,3 sekunderna tog\nvägen, span för span:\n\n```text\nPOST /checkout                       2.30 s   service checkout\n  SELECT cart                        0.04 s   service checkout\n  POST /authorise                    2.21 s   service payments\n    event: provider timeout, retrying\n  INSERT order                       0.03 s   service checkout\n```\n\nTredje steget hämtar loggraderna som bär samma spår-id. OpenTelemetrys\nspecifikation för loggar i andra format än projektets eget ber att id:na i JSON\nskrivs som fält på översta nivån med namnen `trace_id` och `span_id`, med små\nbokstäver och hexadecimalt kodade:\n\n```json\n{\n    \"timestamp\": 1793110051.402,\n    \"severity\": \"WARN\",\n    \"body\": \"provider timeout after 2000 ms, retrying\",\n    \"provider\": \"acquirer-b\",\n    \"trace_id\": \"3f1c9a77e2b04d18a6c5e0b9d4127f60\",\n    \"span_id\": \"a91c04e7d2f3b658\"\n}\n```\n\nTre steg, och frågan som ingen hade planerat för har fått ett svar: den ena av\ntvå betalleverantörer började svara för sent, och varje köp som skickades dit\nväntade på ett nytt försök. Samma attribut, `provider`, kan nu användas för att\ngruppera alla färska spår, så att mönstret är bekräftat innan någon rör koden.\n\nInget av detta fungerar om tjänsterna inte talar om vilka de är.\nOpenTelemetrys SDK:er sätter som standard resursattributet `service.name` till\n`unknown_service`, och dokumentationen rekommenderar att det sätts uttryckligen,\ni koden eller med en miljövariabel. Andra resursattribut kan läggas till på\nsamma sätt:\n\n```sh\nenv OTEL_SERVICE_NAME=checkout \\\n    OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=production \\\n    ./checkout\n```\n\nPå den här webbplatsen visar tre poster i portföljen hur observerbarhet byggs\nupp steg för steg. Den första beskriver\n[ett företags första observerbarhetsdashboard](/sv/portfolio/built-the-companys-first-observability-dashboard/),\nsom samlade in systemmått som CPU, minne och disk från Linux-servrar på distans\nvia SSH; senare byggdes en andra version med Grafana och Prometheus. Arbetet med\natt\n[minska driftrisken med Grafana och Prometheus](/sv/portfolio/cut-operational-risk-with-grafana-and-prometheus/)\ninstrumenterade de viktigaste tjänsterna och valde mätvärden som betydde något\nframför siffror för syns skull. En senare post,\n[egen felövervakning och spårning](/sv/portfolio/built-first-party-error-monitoring-and-tracing/),\nlade till spårning med OpenTelemetry över OTLP, så att ett långsamt anrop kan\nföljas genom frontenden, API:t och databasen i stället för att gissas fram,\ntillsammans med en felpipeline som sanerar nyttolaster före lagring.\n\n## Var det går fel\n\n**Att köpa det i stället för att bygga in det.** Ett nytt verktyg som inget\nanvändbart flödar in i är ett tomt rum. Observerbarhet kommer från\ninstrumentering i koden och biblioteken, så avsätt utvecklartid för att lägga\ntill span, attribut och loggfält, inte bara pengar till licensen.\n\n**Tre signaler, tre öar.** Mätvärden i ett verktyg, loggar i ett annat och spår\ni ett tredje, utan någon gemensam nyckel mellan dem, gör att teamet sitter och\nkopierar tidsstämplar från en skärm till en annan. Skriv in spårets och spannets\nid:n i varje loggpost, lägg exemplars på histogram över svarstid där verktygen\nstöder det, och ge alla signaler samma resursattribut.\n\n**Alla tjänster heter unknown_service.** Det är standardvärdet i SDK:n, och en\nhel flotta av tjänster med samma namn går inte att skilja åt. Sätt\n`OTEL_SERVICE_NAME` för varje tjänst. Resursen knyts till när tracer- och\nmetric-providerna skapas och kan inte ändras efteråt, så den måste vara rätt\nfrån start.\n\n**Bara kanterna är instrumenterade.** Zero-code-instrumentering är en bra start\noch registrerar vad som händer i kanterna av en applikation: i dess bibliotek\noch i miljön den körs i. Frågorna under en incident handlar oftast om\nverksamheten: vilken kundnivå, vilken leverantör, vilket värde en\nfunktionsflagga hade. Det kräver attribut som läggs till i koden.\nOpenTelemetrys dokumentation kallar kodbaserad instrumentering ett komplement\ntill zero-code, och de två kan köras samtidigt.\n\n**Att instrumentera mitt under incidenten.** Om svaret krävde en ny loggrad och\nen ny driftsättning var systemet inte ordentligt instrumenterat enligt\nintroduktionens eget mått. Gör ”vad var vi tvungna att lägga till?” till en\nstående fråga i varje genomgång efter en incident, och behandla varje svar som\nen uppföljningsuppgift.\n\n**Obegränsade detaljer i fel signal.** Användar-id:n, fullständiga URL:er och\ninnehållet i begäranden hör hemma på span och loggposter, inte i mätvärdenas\netiketter, där varje nytt värde skapar en ny tidsserie. OpenMetrics-standarden\nbegränsar etikettnamnen och etikettvärdena på ett exemplar till 128 tecken\nsammanlagt, just för att hindra att exemplars används för att bära span-data,\noch den låter en mottagare kasta exemplars helt. Kontrollera att kopplingarna\növerlever hela vägen från exportören till skärmen innan ni förlitar er på dem.\n\n**Telemetri som läcker.** Span och loggar registrerar vad begärandena\ninnehöll, och det kan omfatta adresser, namn och token. Bestäm vilka attribut\nsom får registreras, rensa bort resten före lagring och skydda telemetrin lika\nnoga som databasen den beskriver.\n\n## Läs mer\n\n- [Observability primer](https://opentelemetry.io/docs/concepts/observability-primer/)\n  — OpenTelemetry-projektets definition, med tillförlitlighet, SLI:er och SLO:er,\n  span och distribuerade spår.\n- [Signals](https://opentelemetry.io/docs/concepts/signals/) — spår, mätvärden,\n  loggar och baggage, och de signaler som fortfarande är under utveckling.\n- [Instrumentation](https://opentelemetry.io/docs/concepts/instrumentation/) —\n  kodbaserad och zero-code-instrumentering, och hur kontext som skickas vidare\n  binder ihop signalerna.\n- [Resources](https://opentelemetry.io/docs/concepts/resources/) —\n  resursattribut, standardvärdet `unknown_service` och miljövariablerna som\n  sätter dem.\n- [Trace Context in non-OTLP Log Formats](https://opentelemetry.io/docs/specs/otel/compatibility/logging_trace_context/)\n  — den stabila specifikationen för hur spår- och span-id:n skrivs i syslog,\n  ren text och JSON-loggar.\n- [OpenMetrics 1.0](https://prometheus.io/docs/specs/om/open_metrics_spec/) —\n  standarden för exponeringsformatet, med exemplars och råden om kardinalitet.\n\n\u003chttps://engineer.company/sv/glossary/observability/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Vad observerbarhet är, hur spår, mätvärden och loggar knyts ihop av gemensamma id:n, och vanorna som gör ett system svårt att ställa frågor till.","formats":{"gemtext":"https://engineer.company/sv/glossary/observability/index.gmi","gopher":"https://engineer.company/sv/glossary/observability/gophermap","html":"https://engineer.company/sv/glossary/observability/","json":"https://engineer.company/sv/glossary/observability/index.json","markdown":"https://engineer.company/sv/glossary/observability/index.md","pdf":"https://engineer.company/sv/glossary/observability/index.pdf"},"kind":"page","language":"sv","title":"Vad är observerbarhet?","url":"https://engineer.company/sv/glossary/observability/","version":1}