Hur närmar du dig loggning och övervakning i produktions-Node?

Question

Accepted Answer

**Loggning** registrerar vad din app gör; **övervakning** spårar dess hälsa och prestanda. Tillsammans ger de dig **observerbarhet** — förmågan att förstå och debugga ett körs produktionssystem. `console.log` är otillräckligt för detta; du behöver strukturerade loggar, mätvärden och aviseringar.

## Strukturerad loggning (inte console.log)

```js
import pino from "pino";
const logger = pino();

// ✅ structured JSON logs — machine-parseable, searchable, with context
logger.info({ userId: 123, action: "login", ip: req.ip }, "user logged in");
logger.error({ err, requestId }, "failed to process order");
```

Använd en strukturerad logger (pino/winston) som matar ut **JSON** med konsekventa fält. JSON-loggar är sökbara och filterbara i loggaggregeringsverktyg, till skillnad från friforma `console.log`-strängar. Inkludera kontext (användar-id, förfrågan-id) på varje logg.

## Loggnivåer och vad som ska loggas

```text
Levels: error > warn > info > debug (configure threshold per environment)
Log:    requests, errors with stack traces, key business events, slow operations
DON'T log: passwords, tokens, PII, full payloads with secrets (security/privacy)
```

## Korrelations-ID spårar en förfrågan mellan tjänster

```js
// attach a unique id per request, include it in EVERY log for that request
app.use((req, res, next) => {
  req.id = crypto.randomUUID();
  res.setHeader("X-Request-Id", req.id);
  next();
});
// now you can filter all logs for one request — vital in microservices
```

Ett **korrelations-/förfrågan-ID** låter dig återskapa hela historien för en enskild förfrågan, även över flera tjänster — oumbärligt för felsökning av distribuerade system.

## Centralisera loggar

```text
Ship logs to a central platform (ELK/Elasticsearch, Datadog, Grafana Loki, CloudWatch)
→ search/aggregate across all instances; don't grep files on individual servers.
```

## Övervakning: mätvärden, aviseringar, spårning

```text
Metrics:  request rate, error rate, latency (p50/p95/p99), CPU/memory, event-loop lag
          (often via Prometheus + Grafana, or an APM like Datadog/New Relic)
Health:   /health & /ready endpoints for load balancers and orchestrators
Alerting: notify (PagerDuty/Slack) when error rate spikes or latency degrades
Tracing:  distributed tracing (OpenTelemetry) to follow requests across services
Errors:   error tracking (Sentry) for aggregated exceptions with stack traces & context
```

Nyckelvärdena att bevaka är **"gyllene signalerna"**: latens, trafik, fel och mättnad. Aviseringar på dessa fångar problem innan användarna rapporterar dem.

## Varför det är viktigt

I produktion kan du inte koppla en debugger — **observerbarhet genom loggning och övervakning är hur du förstår, felsöker och driver** ett levande system.

Strukturerade JSON-loggar med korrelations-ID gör incidenter diagnostiserbara (särskilt över mikrotjänster); centraliserad aggregering gör loggar användbara i stor skala; och övervakning med mätvärden, hälsokontroller, distribuerad spårning och aviseringar låter dig detektera och reagera på problem proaktivt snarare än efter att användare klagar.

Att bygga detta in (inte lägga till det efter ett avbrott) är en definerande praxis för att driva tillförlitliga produktions-Node-tjänster.