ਤੁਸੀਂ ਉਤਪਾਦਨ Node ਵਿੱਚ logging ਅਤੇ monitoring ਨਾਲ ਕਿਵੇਂ ਪਹੁੰਚਦੇ ਹੋ?

Question

Accepted Answer

**Logging** ਰਿਕਾਰਡ ਕਰਦਾ ਹੈ ਕਿ ਤੁਹਾਡੀ ਐਪ ਕੀ ਕਰਦੀ ਹੈ; **monitoring** ਇਸ ਦੀ ਸਿਹਤ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਟ੍ਰੈਕ ਕਰਦਾ ਹੈ। ਇਕੱਠੇ ਉਹ ਤੁਹਾਨੂੰ **observability** ਦਿੰਦੇ ਹਨ — ਇੱਕ ਚਲਦੀ ਹੋਈ ਉਤਪਾਦਨ ਪ੍ਰਣਾਲੀ ਨੂੰ ਸਮਝਣ ਅਤੇ ਡੀਬੱਗ ਕਰਨ ਦੀ ਯੋਗਤਾ। `console.log` ਇਸ ਲਈ ਨਾਕਾਫੀ ਹੈ; ਤੁਹਾਨੂੰ ਸਟ੍ਰਕਚਰਡ 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** output ਕਰਦਾ ਹੈ। 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 ਨੂੰ 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** ਤੁਹਾਨੂੰ ਇੱਕ ਸਿੰਗਲ request ਦੀ ਪੂਰੀ ਕਹਾਣੀ ਦੁਬਾਰਾ ਬਣਾਉਣ ਦਿੰਦਾ ਹੈ, ਇੱਥੇ ਤੱਕ ਕਿ ਮਲਟੀਪਲ ਸੇਵਾਵਾਂ ਵਿੱਚ — distributed systems ਦੀ ਡੀਬੱਗਿੰਗ ਲਈ ਲਾਜ਼ਮੀ।

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

ਧਿਆਨ ਦੇਣ ਵਾਲੇ ਮੁੱਖ metrics **"golden signals"** ਹਨ: latency, traffic, errors ਅਤੇ saturation। ਇਨ੍ਹਾਂ ਤੇ alerting ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੜ੍ਹ ਲੈਂਦਾ ਹੈ ਪਹਿਲਾਂ ਕਿ ਉਪਭੋਗੀ ਉਨ੍ਹਾਂ ਦੀ ਰਿਪੋਰਟ ਕਰਨ।

## ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ ਕਿਉਂ

ਉਤਪਾਦਨ ਵਿੱਚ ਤੁਸੀਂ ਇੱਕ debugger ਨਹੀਂ ਲਗਾ ਸਕਦੇ — **logging ਅਤੇ monitoring ਦੁਆਰਾ observability ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ ਇੱਕ live system ਨੂੰ ਕਿਵੇਂ ਸਮਝਦੇ, ਡੀਬੱਗ ਕਰਦੇ ਅਤੇ ਚਲਾਉਂਦੇ ਹੋ**।

Correlation IDs ਦੇ ਨਾਲ Structured JSON logs incidents ਨੂੰ diagnosable ਬਣਾਉਂਦੇ ਹਨ (ਖਾਸ ਕਰਕੇ microservices ਦੇ ਵਿੱਚ); centralized aggregation logs ਨੂੰ scale ਤੇ usable ਬਣਾਉਂਦਾ ਹੈ; ਅਤੇ metrics, health checks, distributed tracing ਅਤੇ alerting ਦੇ ਨਾਲ monitoring ਤੁਹਾਨੂੰ ਸਮੱਸਿਆਵਾਂ ਨੂੰ proactively detect ਅਤੇ respond ਕਰਨ ਦਿੰਦਾ ਹੈ ਬਜਾਏ ਉਪਭੋਗੀਆਂ ਦੀ ਸ਼ਿਕਾਇਤ ਦੇ।

ਇਸ ਨੂੰ ਬਿਲਡਿੰਗ ਵਿੱਚ ਸ਼ਾਮਿਲ ਕਰਨਾ (outage ਦੇ ਬਾਅਦ ਇਸ ਨੂੰ bolt on ਨਾ ਕਰਨਾ) ਭਰੋਸੇਮੰਦ ਉਤਪਾਦਨ Node ਸੇਵਾਵਾਂ ਨੂੰ ਚਲਾਉਣ ਦੀ ਪਰਿਭਾਸ਼ਤ ਪ੍ਰੈਕਟਿਸ ਹੈ।