તમે ઉત્પાદન Node માં લોગિંગ અને મોનિટરીંગ કેવી રીતે કરો છો?

Question

Accepted Answer

**લોગિંગ** તમારી app શું કરે છે તેનો રેકોર્ડ કરે છે; **મોનિટરીંગ** તેના સ્વાસ્થ્ય અને કામગીરીને ટ્રૅક કરે છે. એક સાથે તેઓ તમને **અવલોકનક્ષમતા** આપે છે — ચાલતી ઉત્પાદન પ્રણાલીને સમજવા અને ડિબગ કરવાની ક્ષમતા. `console.log` આ માટે અપર્યાપ્ત છે; તમને સંરચિત લોગ્સ, મેટ્રિક્સ અને સતર્કતાની જરૂર છે.

## સંરચિત લોગિંગ (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");
```

સંરચિત લોગર (pino/winston) નો ઉપયોગ કરો જે સુસંગત ક્ષેત્રો સાથે **JSON** આઉટપુટ કરે છે. JSON લોગ્સ લોગ એગ્રીગેશન સાધનોમાં શોધી શકાય છે અને ફિલ્ટર કરી શકાય છે, મુક્ત-ફોર્મ `console.log` સ્ટ્રીંગ્સથી વિપરીત. દરેક લોગ પર સંદર્ભ (user id, request id) શામેલ કરો.

## લોગ સ્તરો અને શું લોગ કરવું

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

## સંબંધ IDs સેવાઓ પર વિનંતી ટ્રેસ કરે છે

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

એક **સંબંધ/વિનંતી ID** તમને એક જ વિનંતીની સંપૂર્ણ કહાણી પુનર્નિર્માણ કરવાની છૂટ આપે છે, એમ છતાં બહુવિધ સેવાઓ પર — વિતરિત પ્રણાલીઓને ડિબગ કરવા માટે અનિવાર્ય.

## લોગ્સને કેન્દ્રીય બનાવો

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

## મોનિટરીંગ: મેટ્રિક્સ, સતર્કતા, ટ્રેસીંગ

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

ધ્યાન રાખવાના મુખ્ય મેટ્રિક્સ **"સોનાના સંકેતો"** છે: વિલંબ, ટ્રાફિક, ભૂલો અને સંતૃપ્તિ. આ પર સતર્કતા એ સમસ્યાઓ ધરી પાડે છે તે પહેલાં કે વપરાશકર્તાઓ તેમની જાણ કરે.

## તે શા માટે મહત્વપૂર્ણ છે

ઉત્પાદનમાં તમે ડીબગર સાથે જોડી શકતા નથી — **લોગિંગ અને મોનિટરીંગ દ્વારા અવલોકનક્ષમતા એ છે કે તમે જીવંત પ્રણાલીને કેવી રીતે સમજો, ડિબગ કરો અને સંચાલિત કરો**.

સંરચિત JSON લોગ્સ સંબંધ IDs સાથે ઘટનાને નির્ધાર્ય બનાવે છે (ખાસ કરીને માઇક્રોસર્વિસેસ પર); કેન્દ્રીય એકીકરણ લોગ્સને સ્કેલ પર ઉપયોગી બનાવે છે; અને મેટ્રિક્સ, સ્વાસ્થ્ય તપાસણી, વિતરિત ટ્રેસીંગ અને સતર્કતા સાથે મોનિટરીંગ તમને સમસ્યાઓ સક્રિયતાથી સનાક્ત અને પ્રતિક્રિયા આપવા દે છે તે બદલે વપરાશકર્તાઓ ફરિયાદ કર્યા પછી.

આ બનાવવું (આઉટેજ પછી તેને બોલ્ટ ન કરીને) એ વિશ્વાસપાત્ર ઉત્પાદન Node સેવાઓ ચલાવવાનો વ્યાખ્યાયિત પ્રથા છે.