आप production Node में logging और monitoring को कैसे संभालते हैं?

Question

Accepted Answer

**लॉगिंग** आपके ऐप को क्या करता है इसे रिकॉर्ड करती है; **निगरानी** इसके स्वास्थ्य और प्रदर्शन को ट्रैक करती है। साथ मिलकर वे आपको **अवलोकनीयता** देते हैं — एक चलती production प्रणाली को समझने और debug करने की क्षमता। `console.log` इसके लिए अपर्याप्त है; आपको structured logs, metrics और alerting की आवश्यकता है।

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

एक structured logger (pino/winston) का उपयोग करें जो consistent fields के साथ **JSON** आउटपुट करता है। JSON logs को log aggregation tools में searchable और filterable हैं, मुक्त-रूप `console.log` strings के विपरीत। हर log पर context (user id, request id) शामिल करें।

## Log levels और क्या 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 एक request को services में trace करते हैं

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

एक **correlation/request ID** आपको एक single request की पूरी कहानी को reconstruct करने देता है, भले ही कई services में — distributed systems को debug करने के लिए आवश्यक।

## Logs को centralize करें

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

देखने के लिए key metrics **"golden signals"** हैं: latency, traffic, errors और saturation। इन पर alerting समस्याओं को पकड़ता है users की रिपोर्ट करने से पहले।

## यह क्यों महत्वपूर्ण है

Production में आप debugger को attach नहीं कर सकते — **logging और monitoring के माध्यम से अवलोकनीयता है कि आप कैसे समझते, debug करते और operate करते हैं** एक live system।

Correlation IDs के साथ Structured JSON logs incidents को diagnosable बनाते हैं (खासकर microservices में); centralized aggregation logs को scale पर usable बनाता है; और metrics, health checks, distributed tracing और alerting के साथ निगरानी आपको proactively समस्याओं का detect करने और respond करने देती है बजाय users की शिकायत के बाद।

इसे बनाना (outage के बाद bolt न करना) reliable production Node services चलाने का एक defining practice है।