How do you approach logging and monitoring in production Node?

Question

Accepted Answer

**Logging** records what your app does; **monitoring** tracks its health and performance. Together they give you **observability** — the ability to understand and debug a running production system. `console.log` is inadequate for this; you need structured logs, metrics, and alerting.

## Structured logging (not 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");
```

Use a structured logger (pino/winston) that outputs **JSON** with consistent fields. JSON logs are searchable and filterable in log aggregation tools, unlike free-form `console.log` strings. Include context (user id, request id) on every log.

## Log levels and what to log

```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)
```

## Correlation IDs trace a request across services

```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
```

A **correlation/request ID** lets you reconstruct the full story of a single request, even across multiple services — indispensable for debugging distributed systems.

## Centralize logs

```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.
```

## Monitoring: metrics, alerts, tracing

```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
```

The key metrics to watch are the **"golden signals"**: latency, traffic, errors, and saturation. Alerting on these catches problems before users report them.

## Why it matters

In production you can't attach a debugger — **observability through logging and monitoring is how you understand, debug, and operate** a live system.

Structured JSON logs with correlation IDs make incidents diagnosable (especially across microservices); centralized aggregation makes logs usable at scale; and monitoring with metrics, health checks, distributed tracing, and alerting lets you detect and respond to problems proactively rather than after users complain.

Building this in (not bolting it on after an outage) is a defining practice of running reliable production Node services.