तुम production Node मध्ये logging आणि monitoring कशा पद्धतीने हाताळता?

Question

Accepted Answer

**Logging** तुमचा अॅप काय करतो हे रेकॉर्ड करते; **monitoring** त्याचे आरोग्य आणि कार्यक्षमता ट्रॅक करते. एकत्रितपणे ते तुम्हाला **observability** देतात — चालू असलेल्या production system ला समजून घेण्याची आणि 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) वापरा जो सुसंगत fields सह **JSON** आउटपुट करतो. JSON logs log aggregation tools मध्ये शोधक्षम आणि फिल्टरेबल आहेत, मुक्त-फॉर्म `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 मध्ये ट्रेस करतात

```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** तुम्हाला एकाच request ची संपूर्ण कथा पुनरुज्जीवित करण्यास अनुमती देते, अगदी multiple services च्या आर — distributed systems debug करण्यासाठी अत्यावश्यक.

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

पाहायच्या मुख्य metrics हे **"golden signals"** आहेत: latency, traffic, errors आणि saturation. यावरील alerting users त्यांची तक्रार करण्याआधी समस्या पकडतो.

## का महत्वाचे आहे

Production मध्ये तुम्ही debugger जोडू शकत नाही — **logging आणि monitoring द्वारे observability म्हणजे तुम्ही कसे समजून घेता, debug करता आणि परिचालन करता** एक चालू असलेले system.

Correlation IDs सह structured JSON logs incidents diagnosable बनवतात (विशेषतः microservices च्या बाजूने); centralized aggregation मोठ्या प्रमाणावर logs वापरायोग्य बनवतो; आणि metrics, health checks, distributed tracing आणि alerting सह monitoring तुम्हाला समस्यांचे समस्या शोधून काढू शकता आणि प्रतिक्रिया दिल्यानंतर पुढे जाऊ शकता अर्जदारांच्या तक्रारीनंतर.

हे तयार करणे (outage नंतर बोल्ट न करता) विश्वसनीय production Node services चलाविण्याचा परिभाषित सराव आहे.