{"canonical_url":"https://engineer.company/da/glossary/observability/","content_markdown":"# Observerbarhed\n\n## Hvad det er\n\nObserverbarhed er graden af, hvor godt et team kan forstå, hvad et kørende\nsystem foretager sig, udelukkende ud fra de data, systemet selv sender ud, uden\nat skille det ad og uden på forhånd at vide, hvad der er gået galt.\nOpenTelemetry-projektets introduktion formulerer det som et spørgsmål om\nspørgsmål: Et observerbart system lader dig spørge ind til det uden at kende dets\nindre, også med spørgsmål, som ingen tænkte på, da softwaren blev skrevet.\nIntroduktionen opsummerer det spørgsmål, systemet skal kunne besvare, som\n»Hvorfor sker det her?«\n\nDermed er observerbarhed en egenskab ved systemet, ikke et produkt. Et værktøj\nkan gemme og vise data, men data skal først komme fra applikationen.\nOpenTelemetrys dokumentation siger det ligeud: For at et system kan være\nobserverbart, skal dets komponenter være instrumenteret, det vil sige, at deres\nkode sender signaler ud. Den sætter også en praktisk målestok. En applikation er\nordentligt instrumenteret, når udviklerne ikke behøver at tilføje mere\ninstrumentering for at fejlsøge et problem, fordi oplysningerne allerede er der.\n\nData kaldes telemetri, og OpenTelemetry deler dem op i signaler:\n\n- **Spor** (traces) viser den vej, én forespørgsel tager gennem systemet. Et spor\n  består af spans, som hver er en enkelt arbejdsenhed med et navn, et start- og\n  sluttidspunkt og attributter som HTTP-metoden og ruten. Det første span er\n  roden og dækker forespørgslen fra start til slut.\n- **Metrikker** er målinger, der tages under kørslen og samles over tid:\n  fejlrate, antal forespørgsler pr. tidsenhed, processorforbrug.\n- **Logs** er tidsstemplede registreringer af hændelser. Mange af dem hører ikke\n  til en bestemt forespørgsel.\n- **Baggage** er kontekstoplysninger, der sendes med en forespørgsel, så andre\n  signaler kan bruge dem.\n\nSignalsiden nævner desuden events, en særlig type log, og profiler, der\nregistrerer ressourceforbrug på kodeniveau, som signaler, der er under udvikling\neller på forslagsstadiet.\n\nDet, der gør tre bunker data til noget, et team kan stille spørgsmål til, er\nsammenkædning. OpenTelemetry sender kontekst videre mellem tjenester, så et span\ni én tjeneste ved, hvilket spor det hører til, og det kan stemple id'erne for det\naktive spor og span på hver logpost. Hvert signal bærer også en ressource:\nattributter, der identificerer det, der har produceret signalet, for eksempel\ntjenestens navn, værten eller containeren. Med de fælles nøgler kan et team gå\nfra en metrik til forespørgslerne bag den og fra en forespørgsel til de\nloglinjer, den efterlod.\n\nObserverbarhed og overvågning overlapper hinanden, men de er ikke det samme.\nOvervågning holder øje med forhold, som nogen på forhånd har besluttet at\ninteressere sig for, og slår alarm, når et af dem opstår. Observerbarhed er det,\nteamet har at arbejde med, når alarmen er gået, og årsagen er noget, ingen havde\nforudset.\n\n## Hvorfor det betyder noget\n\nModerne systemer fejler på måder, der er svære at forudsige. En forespørgsel kan\npassere en gateway, flere tjenester, en kø og en database, før den får svar, og\nen fejl i én af dem kan vise sig som langsomhed et helt andet sted.\nIntroduktionen kalder distribueret sporing afgørende for den slags systemer,\nfordi deres problemer ofte er ikke-deterministiske eller for komplicerede til at\ngenskabe på en udviklers egen maskine. Når en fejl ikke kan genskabes, er den\ntelemetri, der blev optaget, mens den skete, det eneste bevis, der findes.\n\nDashboards og alarmer besvarer spørgsmål, som nogen har forudset. Det er\nværdifuldt, og det dækker de fejl, teamet har set før. De svære driftshændelser\ner de nye, hvor spørgsmålet ikke er, om fejlraten steg, men hvorfor\nforespørgsler fra én region, gennem én version, til én betalingsudbyder begyndte\nat fejle. Hvis svaret kræver, at man skriver ny kode, udruller den og venter på,\nat problemet kommer igen, varer nedbruddet lige så længe som den omvej.\n\nObserverbarhed holder også brugeren i fokus. Introduktionen definerer\npålidelighed som et spørgsmål om, hvorvidt tjenesten gør det, brugerne\nforventer, og giver et eksempel: En webbutik kan være oppe hele tiden og alligevel\nvære upålidelig, hvis et klik for at lægge sorte sko i kurven ikke altid lægger\nsorte sko i kurven. Det ville en måling på serverniveau aldrig vise. Telemetri\nfra de enkelte forespørgsler kan, og det er den, serviceniveauindikatorer bygges\naf: målinger set fra brugerens side, som serviceniveaumål derefter knytter til\ndet, forretningen har brug for.\n\nEndelig ændrer det, hvad en driftshændelse koster. Et team, der kan følge en\nlangsom forespørgsel til netop det kald, der holdt den tilbage, bruger tiden på\nat rette og ikke på at gætte, og den efterfølgende postmortem kan henvise til\nbeviser i stedet for erindringer.\n\n## Sådan ser det ud i praksis\n\nForestil dig en opdigtet webbutik. Siden klokken 14 tager en lille andel af\nforløbene i kassen mere end to sekunder. Intet er nede, ingen alarm er gået, og der\nfindes intet dashboard til netop dette. Sådan ville et team med sammenkædede\nsignaler gribe det an. Alle navne, id'er og tal nedenfor er opfundet til\neksemplet.\n\nFørste skridt er histogrammet over svartiden i kassen, målt i sekunder. I\nOpenMetrics' tekstformat kan en bucket have et exemplar efter et `#`: en\nhenvisning til data uden for metrikken, oftest id'et på et spor, der landede i\nden bucket. To af dens buckets ser sådan ud:\n\n```text\ncheckout_bucket{le=\"1.0\"} 95\ncheckout_bucket{le=\"2.5\"} 97 # {trace_id=\"3f1c9a77e2b04d18a6c5e0b9d4127f60\"} 2.3\n```\n\nAndet skridt følger det spor-id. Sporet viser, hvor de 2,3 sekunder gik hen, span\nfor 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 skridt henter de loglinjer, der bærer samme spor-id. OpenTelemetrys\nspecifikation for logs i andre formater end projektets egen protokol beder om,\nat id'erne i JSON skrives som felter på øverste niveau med navnene `trace_id` og\n`span_id`, med små bogstaver og hex-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 skridt, og det spørgsmål, ingen havde planlagt, har et svar: Den ene af to\nbetalingsudbydere begyndte at svare for sent, og hvert forløb i kassen, som brugte\nden udbyder, ventede på et nyt forsøg. Den samme attribut, `provider`, kan nu bruges\ntil at gruppere alle nylige spor, så mønstret er bekræftet, før nogen rører\nkoden.\n\nIntet af det virker, hvis tjenesterne ikke siger, hvem de er.\nOpenTelemetry-SDK'erne sætter som standard ressourceattributten `service.name`\ntil `unknown_service`, og dokumentationen anbefaler at sætte den eksplicit, i\nkoden eller via en miljøvariabel. Andre ressourceattributter kan tilføjes på\nsamme måde:\n\n```sh\nenv OTEL_SERVICE_NAME=checkout \\\n    OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=production \\\n    ./checkout\n```\n\nPå dette site viser tre porteføljeopgaver, hvordan observerbarhed bygges op i\ntrin. Den ene beskriver\n[en virksomheds første observerbarhedsdashboard](/da/portfolio/built-the-companys-first-observability-dashboard/),\nsom samlede systemmålinger som CPU, hukommelse og disk ind fra fjerne\nLinux-servere over SSH; en anden version blev senere bygget på Grafana og\nPrometheus. Arbejdet med at\n[mindske driftsrisikoen med Grafana og Prometheus](/da/portfolio/cut-operational-risk-with-grafana-and-prometheus/)\ninstrumenterede de vigtigste tjenester og valgte metrikker, der betød noget,\nfrem for tal, der kun ser flotte ud. En senere opgave,\n[egen fejlovervågning og tracing](/da/portfolio/built-first-party-error-monitoring-and-tracing/),\ntilføjede sporing med OpenTelemetry over OTLP, så en langsom forespørgsel kan\nfølges på tværs af frontenden, API'et og databasen i stedet for at blive gættet\npå, sammen med en fejlpipeline, der renser indholdet, før det gemmes.\n\n## Hvor det går galt\n\n**At købe det i stedet for at bygge det ind.** Et nyt værktøj, som intet\nbrugbart løber ind i, er et tomt rum. Observerbarhed kommer fra instrumentering i\nkoden og bibliotekerne, så sæt udviklertid af til at tilføje spans, attributter\nog logfelter, ikke kun penge til licensen.\n\n**Tre signaler, tre øer.** Metrikker i ét værktøj, logs i et andet og spor i et\ntredje, uden en fælles nøgle imellem, efterlader teamet med at kopiere\ntidsstempler fra den ene skærm til den anden. Skriv spor- og span-id'erne i hver\nlogpost, sæt exemplars på histogrammer over svartid, hvor værktøjerne\nunderstøtter det, og giv alle signaler de samme ressourceattributter.\n\n**Alle tjenester hedder unknown_service.** Det er SDK'ens standard, og en flåde\naf tjenester med samme navn kan ikke skelnes fra hinanden. Sæt\n`OTEL_SERVICE_NAME` for hver tjeneste. Ressourcen knyttes til, når tracer- og\nmetric-providerne oprettes, og kan ikke ændres bagefter, så den skal være rigtig\nfra opstarten.\n\n**Kun kanterne er instrumenteret.** Zero-code-instrumentering er en god start og\nregistrerer, hvad der sker i kanten af en applikation: i dens biblioteker og i\ndet miljø, den kører i. Spørgsmålene under en driftshændelse handler som regel\nom forretningen: hvilken kundetype, hvilken udbyder, hvilken værdi et\nfeature-flag havde. Det kræver attributter, der tilføjes i koden.\nOpenTelemetrys dokumentation kalder kodebaseret instrumentering et supplement til\nzero-code, og de to kan køre samtidig.\n\n**At instrumentere midt i driftshændelsen.** Hvis svaret krævede en ny loglinje\nog en udrulning, var systemet ikke ordentligt instrumenteret efter\nintroduktionens egen målestok. Gør »hvad måtte vi tilføje?« til et fast spørgsmål\ni hver gennemgang efter en driftshændelse, og behandl hvert svar som en\nopfølgningsopgave.\n\n**Ubegrænsede detaljer i det forkerte signal.** Bruger-id'er, fulde URL'er og\nindholdet af forespørgsler hører hjemme på spans og logposter, ikke i\nmetrikkernes labels, hvor hver ny værdi skaber endnu en tidsserie.\nOpenMetrics-standarden begrænser et exemplars labelnavne og -værdier til 128\ntegn i alt, netop for at forhindre, at exemplars bruges til at bære span-data, og\nden tillader en modtager helt at kassere exemplars. Kontrollér, at koblingerne\noverlever hele vejen fra eksportøren til skærmen, før I regner med dem.\n\n**Telemetri, der lækker.** Spans og logs registrerer, hvad forespørgsler\nindeholdt, og det kan omfatte adresser, navne og tokens. Beslut, hvilke\nattributter der må registreres, fjern resten, før det gemmes, og beskyt\ntelemetrien lige så omhyggeligt som den database, den beskriver.\n\n## Læs mere\n\n- [Observability primer](https://opentelemetry.io/docs/concepts/observability-primer/)\n  — OpenTelemetry-projektets definition med pålidelighed, SLI'er og SLO'er, spans\n  og distribuerede spor.\n- [Signals](https://opentelemetry.io/docs/concepts/signals/) — spor, metrikker,\n  logs og baggage samt de signaler, der stadig er under udvikling.\n- [Instrumentation](https://opentelemetry.io/docs/concepts/instrumentation/) —\n  kodebaseret og zero-code-instrumentering, og hvordan kontekst, der sendes\n  videre, binder signalerne sammen.\n- [Resources](https://opentelemetry.io/docs/concepts/resources/) —\n  ressourceattributter, standardværdien `unknown_service` og de miljøvariabler,\n  der sætter dem.\n- [Trace Context in non-OTLP Log Formats](https://opentelemetry.io/docs/specs/otel/compatibility/logging_trace_context/)\n  — den stabile specifikation for, hvordan spor- og span-id'er skrives i syslog,\n  almindelig tekst og JSON-logs.\n- [OpenMetrics 1.0](https://prometheus.io/docs/specs/om/open_metrics_spec/) —\n  standarden for eksponeringsformatet, herunder exemplars og dens råd om\n  kardinalitet.\n\n\u003chttps://engineer.company/da/glossary/observability/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvad observerbarhed er, hvordan spor, metrikker og logs bindes sammen af fælles id'er, og de vaner, der gør et system svært at stille spørgsmål til.","formats":{"gemtext":"https://engineer.company/da/glossary/observability/index.gmi","gopher":"https://engineer.company/da/glossary/observability/gophermap","html":"https://engineer.company/da/glossary/observability/","json":"https://engineer.company/da/glossary/observability/index.json","markdown":"https://engineer.company/da/glossary/observability/index.md","pdf":"https://engineer.company/da/glossary/observability/index.pdf"},"kind":"page","language":"da","title":"Hvad er observerbarhed?","url":"https://engineer.company/da/glossary/observability/","version":1}