Vad är observability och varför är det viktigt i systemdesign?

Question

Accepted Answer

**Observability** är förmågan att förstå ett systems interna tillstånd från dess externa utmatningar — genom **logs**, **metrics** och **traces**. Det är essentiellt för att driva, debugga och underhålla system (särskilt distribuerade sådana), där du inte kan hantera vad du inte kan se.

## De tre pelarna för observability

```text
LOGS → timestamped records of events (what happened) → detailed, for debugging specific issues
METRICS → numerical measurements over time (CPU, latency, request rate, error rate) →
  aggregate health/performance; dashboards; alerting
TRACES → follow a request's path through the system (across services) → understand flows,
  find bottlenecks/failures in DISTRIBUTED systems (which service was slow?)
→ together: understand WHAT happened, the OVERALL state, and the PATH of requests.
```

## Varför observability är viktigt

```text
✓ You can't operate/debug what you can't SEE → essential for understanding system behavior
✓ DETECT problems → metrics + alerting catch issues (before/as users hit them)
✓ DEBUG → logs and traces find root causes (especially in distributed systems where a
  request crosses many services — hard to debug without tracing)
✓ UNDERSTAND performance → find bottlenecks, optimize
✓ Maintain RELIABILITY → observability enables fast detection and resolution (lower MTTR)
```

## Observability vs monitoring

```text
MONITORING → watching KNOWN metrics/conditions (predefined dashboards, alerts) → "is it
  working?"
OBSERVABILITY → ability to ASK NEW questions / explore the unknown → "WHY is it behaving
  this way?" (debug novel/unexpected issues)
→ observability is broader → understand system behavior, including unforeseen problems
✓ practices: structured logging, distributed tracing (OpenTelemetry), good metrics, alerting
```

## Varför det är viktigt

Att förstå observability är viktigt kunskap på seniornivå eftersom **att driva och underhålla system kräver att förstå deras beteende**, och observability är essentiellt för detta (särskilt i distribuerade system), så det är en nyckelaspekt av att designa användbara system.

Observability — att förstå ett systems interna tillstånd från dess externa utmatningar — är essentiellt eftersom **du inte kan hantera, driva eller debugga vad du inte kan se**, vilket gör det kritiskt för att köra system på ett tillförlitligt sätt.

Att förstå **de tre pelarna** — **logs** (händelseposter för detaljerad debugging), **metrics** (numeriska mätningar för aggregerad hälsa, instrumentpaneler och alertering), och **traces** (att följa en requests väg genom tjänster) — och hur de tillsammans låter dig förstå vad som hände, det övergripande tillståndet och request-flöden, är grundläggande kunskap. **Traces** är särskilt viktigt i distribuerade system, där en request passerar många tjänster och debugging är mycket svårt utan att spåra vägen för att hitta vilken tjänst som var långsam eller misslyckades.

Att förstå **varför observability är viktigt** — att det är essentiellt för att driva och debugga system, detektera problem (metrics och alertering som fångar problem), debugga rotorsaker (logs och traces, särskilt i distribuerade system), förstå prestanda, och möjliggöra snabb detektion och lösning (lägre MTTR för tillförlitlighet) — klargör dess kritiska operativa roll.

Att förstå **observability vs monitoring** — monitoring som övervakar kända villkor ("fungerar det?") versus observability som möjliggör att ställa nya frågor och utforska det okända ("varför beter det sig på det här sättet?", debugga nya problem) — återspeglar det djupare konceptet av att kunna förstå oförutsedda problem, viktigt för komplexa system.

Att designa system med observability i åtanke (strukturerad logging, distribuerad spårning, bra metrics, alertering) är essentiellt för användbara, underhållbara system.

Eftersom att driva och underhålla system kräver att förstå deras beteende och observability (logs, metrics, traces) är essentiellt för detta — särskilt i distribuerade system där debugging är svårt utan det — och eftersom det möjliggör att detektera, debugga och lösa problem snabbt, är att förstå observability viktig kunskap på seniornivå — essentiellt för att driva och underhålla system på ett tillförlitligt sätt, en nyckelaspekt av att designa användbara system (särskilt distribuerade sådana där spårning är avgörande), och återspeglar den operativa mognad som förväntas för seniorroller som designar system som måste förstås, debuggas och hållas tillförlitliga i produktion.