{"canonical_url":"https://engineer.company/nb/glossary/observability/","content_markdown":"# Observerbarhet\n\n## Hva det er\n\nObserverbarhet er i hvilken grad et team kan forstå hva et kjørende system\nholder på med utenfra, bare ut fra dataene systemet selv sender ut, uten å åpne\ndet og uten å vite på forhånd hva som har gått galt.\nOpenTelemetry-prosjektets innføring beskriver det med spørsmål: Et observerbart\nsystem lar deg stille spørsmål om det uten å kjenne de indre detaljene, også\nspørsmål ingen tenkte på da programvaren ble skrevet. Innføringen oppsummerer\nspørsmålet systemet skal kunne svare på, som «Hvorfor skjer dette?»\n\nDermed er observerbarhet en egenskap ved systemet, ikke et produkt. Et verktøy\nkan lagre og vise data, men dataene må først komme fra applikasjonen.\nOpenTelemetrys dokumentasjon sier det rett ut: Skal et system være\nobserverbart, må komponentene være instrumentert, det vil si at koden deres\nsender ut signaler. Den setter også en praktisk målestokk. En applikasjon er\nskikkelig instrumentert når utviklerne ikke trenger å legge til mer\ninstrumentering for å feilsøke et problem, fordi opplysningene allerede finnes.\n\nDataene kalles telemetri, og OpenTelemetry deler dem inn i signaler:\n\n- **Spor** (traces) viser veien én forespørsel tar gjennom systemet. Et spor\n  består av span, der hvert span er én arbeidsenhet med et navn, et start- og\n  sluttidspunkt og attributter som HTTP-metoden og ruten. Det første spanet er\n  roten og dekker forespørselen fra start til slutt.\n- **Metrikker** er målinger som tas mens systemet kjører, og som samles over\n  tid: feilrate, antall forespørsler per tidsenhet, prosessorbruk.\n- **Logger** er tidsstemplede registreringer av hendelser. Mange av dem hører\n  ikke til noen bestemt forespørsel.\n- **Baggage** er kontekstopplysninger som sendes med en forespørsel, slik at\n  andre signaler kan bruke dem.\n\nSignalsiden nevner også events, en egen type logg, og profiler, som registrerer\nressursbruk på kodenivå, som signaler under utvikling eller på forslagsstadiet.\n\nDet som gjør tre hauger med data til noe et team kan stille spørsmål til, er\nsammenkobling. OpenTelemetry sender kontekst videre mellom tjenester, slik at\net span i én tjeneste vet hvilket spor det hører til, og det kan stemple ID-ene\ntil det aktive sporet og spanet på hver loggpost. Hvert signal bærer også en\nressurs: attributter som identifiserer det som produserte signalet, for\neksempel tjenestenavnet, verten eller containeren. Med disse felles nøklene kan\net team gå fra en metrikk til forespørslene bak den, og fra en forespørsel til\nlogglinjene den etterlot seg.\n\nObserverbarhet og overvåking overlapper, men de er ikke det samme. Overvåking\nholder øye med forhold som noen på forhånd har bestemt seg for å bry seg om, og\nsender et varsel når ett av dem inntreffer. Observerbarhet er det teamet har å\njobbe med når varselet har gått og årsaken er noe ingen hadde sett for seg.\n\n## Hvorfor det er viktig\n\nModerne systemer svikter på måter som er vanskelige å forutsi. En forespørsel\nkan gå gjennom en gateway, flere tjenester, en kø og en database før den får\nsvar, og en feil i hvilken som helst av dem kan vise seg som treghet et helt\nannet sted. Innføringen kaller distribuert sporing helt nødvendig for slike\nsystemer, fordi problemene deres ofte er ikke-deterministiske eller for\nkompliserte til å gjenskape på en utviklers egen maskin. Når en feil ikke lar\nseg gjenskape, er telemetrien som ble tatt opp mens den skjedde, det eneste\nbeviset som finnes.\n\nDashbord og varsler svarer på spørsmål noen har forutsett. Det er verdifullt,\nog det dekker feilene teamet har sett før. De vanskelige driftshendelsene er de\nnye, der spørsmålet ikke er om feilraten steg, men hvorfor forespørsler fra én\nregion, gjennom én versjon, til én betalingsleverandør begynte å feile. Hvis\nsvaret krever at man skriver ny kode, ruller den ut og venter på at problemet\nkommer tilbake, varer nedetiden like lenge som den omveien.\n\nObserverbarhet holder også brukeren i sentrum. Innføringen definerer\npålitelighet som et spørsmål om tjenesten gjør det brukerne forventer, og gir et\neksempel: En nettbutikk kan være oppe hele tiden og likevel være upålitelig hvis\net klikk for å legge svarte sko i handlekurven ikke alltid legger svarte sko i\nhandlekurven. Det ville en måling på servernivå aldri vise. Telemetri fra\nenkeltforespørsler kan, og det er den tjenestenivåindikatorer bygges av:\nmålinger sett fra brukerens side, som tjenestenivåmål deretter knytter til det\nvirksomheten trenger.\n\nTil slutt endrer det hva en driftshendelse koster. Et team som kan følge en treg\nforespørsel til akkurat det kallet som holdt den igjen, bruker tiden på å rette\ni stedet for å gjette, og postmortemen etterpå kan vise til bevis i stedet for\nerindring.\n\n## Slik ser det ut i praksis\n\nTenk deg en oppdiktet nettbutikk. Siden klokken 14 har en liten andel av\nutsjekkingene tatt mer enn to sekunder. Ingenting er nede, ingen varsler har gått,\nog det finnes ikke noe dashbord for akkurat dette. Slik ville et team med\nsammenkoblede signaler gått fram. Alle navn, ID-er og tall nedenfor er laget\nfor eksempelets skyld.\n\nFørste steg er histogrammet over hvor lang tid utsjekkingene tar, målt i\nsekunder. I tekstformatet til OpenMetrics kan en bucket ha et exemplar etter et\n`#`: en henvisning til data utenfor metrikken, oftest ID-en til et spor som\nhavnet i den bucketen. To av bucketene ser slik ut:\n\n```text\ncheckout_bucket{le=\"1.0\"} 95\ncheckout_bucket{le=\"2.5\"} 97 # {trace_id=\"3f1c9a77e2b04d18a6c5e0b9d4127f60\"} 2.3\n```\n\nAndre steg følger den spor-ID-en. Sporet viser hvor de 2,3 sekundene ble av,\nspan for 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 steg henter logglinjene som bærer den samme spor-ID-en. OpenTelemetrys\nspesifikasjon for logger i andre formater enn prosjektets egen protokoll ber om\nat ID-ene i JSON skrives som felt på øverste nivå med navnene `trace_id` og\n`span_id`, med små bokstaver og heksadesimalt kodet:\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, og spørsmålet ingen hadde planlagt for, har fått et svar: Den ene av\nto betalingsleverandører begynte å svare for sent, og hver utsjekking som brukte\nden leverandøren, ventet på et nytt forsøk. Den samme attributten, `provider`, kan nå\nbrukes til å gruppere alle nylige spor, slik at mønsteret er bekreftet før noen\nrører koden.\n\nIngenting av dette virker hvis tjenestene ikke sier hvem de er.\nOpenTelemetry-SDK-ene setter som standard ressursattributtet `service.name` til\n`unknown_service`, og dokumentasjonen anbefaler å sette det eksplisitt, i koden\neller med en miljøvariabel. Andre ressursattributter kan legges til på samme\nmåte:\n\n```sh\nenv OTEL_SERVICE_NAME=checkout \\\n    OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=production \\\n    ./checkout\n```\n\nPå dette nettstedet viser tre porteføljeoppføringer hvordan observerbarhet\nbygges opp steg for steg. Den ene beskriver\n[et selskaps første observerbarhetsdashbord](/nb/portfolio/built-the-companys-first-observability-dashboard/),\nsom samlet inn systemmålinger som CPU, minne og disk fra eksterne\nLinux-servere over SSH; en ny versjon ble senere bygget på Grafana og\nPrometheus. Arbeidet med å\n[redusere driftsrisikoen med Grafana og Prometheus](/nb/portfolio/cut-operational-risk-with-grafana-and-prometheus/)\ninstrumenterte de viktigste tjenestene og valgte metrikker som betydde noe,\nframfor tall som bare ser pene ut. En senere oppføring,\n[egen feilovervåking og sporing](/nb/portfolio/built-first-party-error-monitoring-and-tracing/),\nla til sporing med OpenTelemetry over OTLP, slik at en treg forespørsel kan\nfølges gjennom frontenden, API-et og databasen i stedet for å bli gjettet på,\nsammen med en feilpipeline som renser nyttelaster før de lagres.\n\n## Hvor det går galt\n\n**Å kjøpe det i stedet for å bygge det inn.** Et nytt verktøy som ingenting\nnyttig strømmer inn i, er et tomt rom. Observerbarhet kommer fra instrumentering\ni koden og bibliotekene, så sett av utviklertid til å legge til span,\nattributter og loggfelt, ikke bare penger til lisensen.\n\n**Tre signaler, tre øyer.** Metrikker i ett verktøy, logger i et annet og spor i\net tredje, uten en felles nøkkel mellom dem, gjør at teamet ender med å kopiere\ntidsstempler fra én skjerm til en annen. Skriv spor- og span-ID-ene inn i hver\nloggpost, legg exemplars på histogrammer over svartid der verktøyene støtter\ndet, og gi alle signaler de samme ressursattributtene.\n\n**Alle tjenester heter unknown_service.** Det er standardverdien i SDK-en, og en\nhel flåte av tjenester med samme navn kan ikke skilles fra hverandre. Sett\n`OTEL_SERVICE_NAME` for hver tjeneste. Ressursen knyttes til når tracer- og\nmetric-providerne opprettes, og kan ikke endres etterpå, så den må være riktig\nfra oppstart.\n\n**Bare kantene er instrumentert.** Zero-code-instrumentering er en god start og\nregistrerer hva som skjer i kantene av en applikasjon: i bibliotekene og i\nmiljøet den kjører i. Spørsmålene under en driftshendelse handler som regel om\nvirksomheten: hvilken kundetype, hvilken leverandør, hvilken verdi et\nfeature-flagg hadde. Det krever attributter som legges til i koden.\nOpenTelemetrys dokumentasjon kaller kodebasert instrumentering et supplement til\nzero-code, og de to kan kjøre samtidig.\n\n**Å instrumentere midt i driftshendelsen.** Hvis svaret krevde en ny logglinje\nog en ny utrulling, var systemet ikke skikkelig instrumentert etter\ninnføringens egen målestokk. Gjør «hva måtte vi legge til?» til et fast\nspørsmål i hver gjennomgang etter en driftshendelse, og behandle hvert svar som\nen oppfølgingsoppgave.\n\n**Ubegrensede detaljer i feil signal.** Bruker-ID-er, fullstendige URL-er og\ninnholdet i forespørsler hører hjemme på span og loggposter, ikke i\nmetrikkenes etiketter, der hver ny verdi skaper en ny tidsserie.\nOpenMetrics-standarden begrenser etikettnavnene og -verdiene på et exemplar til\n128 tegn til sammen, nettopp for å hindre at exemplars brukes til å bære\nspan-data, og den lar en mottaker forkaste exemplars helt. Sjekk at koblingene\noverlever hele veien fra eksportøren til skjermen før dere stoler på dem.\n\n**Telemetri som lekker.** Span og logger registrerer hva forespørslene\ninneholdt, og det kan omfatte adresser, navn og tokener. Bestem hvilke\nattributter som får registreres, fjern resten før lagring, og beskytt\ntelemetrien like nøye som databasen den beskriver.\n\n## Les mer\n\n- [Observability primer](https://opentelemetry.io/docs/concepts/observability-primer/)\n  — OpenTelemetry-prosjektets definisjon, med pålitelighet, SLI-er og SLO-er,\n  span og distribuerte spor.\n- [Signals](https://opentelemetry.io/docs/concepts/signals/) — spor, metrikker,\n  logger og baggage, og signalene som fortsatt er under utvikling.\n- [Instrumentation](https://opentelemetry.io/docs/concepts/instrumentation/) —\n  kodebasert og zero-code-instrumentering, og hvordan kontekst som sendes\n  videre, binder signalene sammen.\n- [Resources](https://opentelemetry.io/docs/concepts/resources/) —\n  ressursattributter, standardverdien `unknown_service` og miljøvariablene som\n  setter dem.\n- [Trace Context in non-OTLP Log Formats](https://opentelemetry.io/docs/specs/otel/compatibility/logging_trace_context/)\n  — den stabile spesifikasjonen for hvordan spor- og span-ID-er skrives i\n  syslog, ren tekst og JSON-logger.\n- [OpenMetrics 1.0](https://prometheus.io/docs/specs/om/open_metrics_spec/) —\n  standarden for eksponeringsformatet, med exemplars og rådene om kardinalitet.\n\n\u003chttps://engineer.company/nb/glossary/observability/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hva observerbarhet er, hvordan spor, metrikker og logger knyttes sammen med felles ID-er, og vanene som gjør et system vanskelig å stille spørsmål til.","formats":{"gemtext":"https://engineer.company/nb/glossary/observability/index.gmi","gopher":"https://engineer.company/nb/glossary/observability/gophermap","html":"https://engineer.company/nb/glossary/observability/","json":"https://engineer.company/nb/glossary/observability/index.json","markdown":"https://engineer.company/nb/glossary/observability/index.md","pdf":"https://engineer.company/nb/glossary/observability/index.pdf"},"kind":"page","language":"nb","title":"Hva er observerbarhet?","url":"https://engineer.company/nb/glossary/observability/","version":1}