உற்பத்தி Node இல் logging மற்றும் monitoring நீ எவ்வாறு அணுகுவாய்?

Question

Accepted Answer

**Logging** உங்கள் app என்ன செய்கிறது என்பதை பதிவு செய்கிறது; **monitoring** அதன் ஆரோக்கியம் மற்றும் செயல்திறனைக் கண்காணிக்கிறது. ஒன்றாக அவை உங்களுக்கு **observability** கொடுக்கின்றன — இயங்கும் உற்பத்தி 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) ஐ பயன்படுத்தவும் அது **JSON** உடன் consistent fields களை output செய்கிறது. JSON logs search செய்யக்கூடிய மற்றும் log aggregation tools இல் filterable, free-form `console.log` strings ற்கு அல்ல. ஒவ்வொரு log இலும் context (user id, request id) include செய்யவும்.

## 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** உங்களை ஒரு request ன் full story ஐ மீண்டும் உருவாக்கவும் கூட்ட, பல 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 கூறுவதற்கு முன் problems ஐ catch செய்கிறது.

## இது ஏன் முக்கியம்

உற்பத்தியில் நீ debugger ஐ attach செய்ய முடியாது — **logging மற்றும் monitoring மூலம் observability ஆகும் நீ கற்பித்து, debug செய்கிறாய், மற்றும் operate செய்கிறாய்** ஒரு live system ஐ.

Correlation IDs உடன் Structured JSON logs incidents ஐ diagnosable செய்கிறது (especially microservices இடையில்); centralized aggregation logs ஐ scale ல் usable செய்கிறது; மற்றும் metrics, health checks, distributed tracing, மற்றும் alerting உடன் monitoring உங்களை proactively problems ஐ detect மற்றும் respond செய்ய அனுமதிக்கிறது users complain செய்த பிறகாக இல்லாமல்.

இதை build செய்வது (outage பிறகு bolt செய்யாமல்) reliable production Node services ஐ run செய்ய defining practice ஆகும்.