19. Observability: Winston Structured Logging, OpenTelemetry & Prometheus Metrics • Node.js Backend Architecture: Libuv to High-Scale Microservices • Rishabh Ki Kaksha

Node.js Backend Architecture: Libuv to High-Scale Microservices › 19. Observability: Winston Structured Logging, OpenTelemetry & Prometheus Metrics

45 mins

← Prev Next →

Course Syllabus

Module 1: Node.js Internals, Libuv & Event Loop Architecture

01. Node.js Architecture: V8, Libuv, C++ Bindings & Non-Blocking I/O 02. Libuv Event Loop 6 Phases: Timers, Pending, Poll, Check (setImmediate) & Close 03. process.nextTick vs setImmediate vs queueMicrotask (Starvation Traps)

Module 2: Buffers, Binary Protocols & Stream Pipelines

04. Buffer Allocation: Buffer.alloc vs Buffer.allocUnsafe & Memory Security 05. Node.js Streams: Readable, Writable, Duplex & Transform Streams 06. Backpressure Management & stream.pipeline vs .pipe() Gotchas

Module 3: Enterprise Express & High-Scale REST API Architecture

07. Production Express Architecture: Controller-Service-Repository Pattern 08. Custom Global Error Handling, Async Handlers & Zod Request Validation 09. High-Performance Caching with Redis & Invalidation Strategies

Module 4: Authentication, Cryptography & Web Security

10. Authentication Architecture: JWT Access/Refresh Tokens & Sliding Sessions 11. Node.js Crypto Module: Password Hashing (Argon2 vs bcrypt) & AES-256-GCM 12. API Security Hardening: Helmet, CORS, Rate Limiting & OWASP Defenses

Module 5: Concurrency, Clustering & Worker Threads

13. Child Processes: spawn vs exec vs execFile vs fork 14. Multi-Core Clustering: Node.js Cluster Module & Zero-Downtime Reloads 15. Worker Threads (worker_threads) & SharedArrayBuffer for CPU-Bound Tasks

Module 6: Microservices, Message Queues (BullMQ/RabbitMQ) & Production Ops

16. Real-Time WebSockets Architecture: Socket.io with Redis Adapter Scaling 17. Asynchronous Task Queues with Redis & BullMQ (Retries, Backoff, Dead Letters) 18. Microservices Architecture: gRPC Protocols with Protocol Buffers in Node.js 19. Observability: Winston Structured Logging, OpenTelemetry & Prometheus Metrics 20. Production PM2 Cluster Deployment, Memory Leak Profiling (heapdump) & Healthchecks

Interactive Lesson Studio

# 19. Observability: Winston Structured Logging, OpenTelemetry & Prometheus Metrics

> Node.js Notes by Rishabh - Topic 19

---

### 1. The 3 Pillars of Observability 🔭

Jab production me bug aata hai, toh `console.log("yaha pahucha")` se debug karna impossible hota hai.

```
       ┌────────────────────────────────────────────────────────┐
       │              THE 3 PILLARS OF OBSERVABILITY            │
       ├─────────────────┬──────────────────┬───────────────────┤
       │ 1. LOGS (JSON)  │ 2. METRICS (Time)│ 3. TRACES (Spans) │
       │ "What happened" │ "Aggregated Stats│ "Where in cluster │
       │ (Winston/Pino)  │ (Prometheus/Graf)│ latency occurred" │
       └─────────────────┴──────────────────┴───────────────────┘
```

---

### 2. Winston Structured JSON Logging with Correlation IDs

```typescript
import winston from "winston";

export const logger = winston.createLogger({
    level: process.env.NODE_ENV === "production" ? "info" : "debug",
    format: winston.format.combine(
        winston.format.timestamp(),
        winston.format.json() // 👑 Datadog / CloudWatch parseable JSON!
    ),
    transports: [
        new winston.transports.Console(),
        new winston.transports.File({ filename: "error.log", level: "error" })
    ]
});

// Express Correlation Middleware:
app.use((req, res, next) => {
    req.id = req.headers["x-request-id"] || crypto.randomUUID();
    logger.info("Incoming Request", { reqId: req.id, method: req.method, url: req.url });
    next();
});
```

---

### 3. Prometheus Metrics with `prom-client` (P99 Latency & Error Rates)

```typescript
import client from "prom-client";

// Collect default Node.js memory / event loop metrics:
client.collectDefaultMetrics();

// Custom HTTP Request Duration Histogram:
export const httpRequestDuration = new client.Histogram({
    name: "http_request_duration_seconds",
    help: "Duration of HTTP requests in seconds",
    labelNames: ["method", "route", "status_code"],
    buckets: [0.01, 0.05, 0.1, 0.5, 1, 2, 5]
});

// Expose /metrics endpoint for Prometheus scraper:
app.get("/metrics", async (req, res) => {
    res.set("Content-Type", client.register.contentType);
    res.end(await client.register.metrics());
});
```

---

### 4. Master Comparison Matrix

---

### 5. Interview Ke 3 Sawal Is Topic Se

1. **Structured JSON logs plain text logs se behtar kyu hote hain?** -> Structured JSON logs me fields (`userId`, `duration`, `statusCode`) easily searchable aur filterable hote hain log aggregation platforms (ELK, Datadog) me.
2. **Prometheus Histogram aur Summary me kya difference hai?** -> Histogram configurable buckets me counts maintain karta hai aur server par P95/P99 calculate karne ki flexibility deta hai; Summary client node par quantiles calculate karta hai.
3. **Distributed Tracing me Trace ID aur Span ID ka kya role hai?** -> Trace ID poore user flow (Frontend ➔ Gateway ➔ Auth ➔ DB) ko single string se track karta hai; Span ID individual microservice ke andar ke task duration ko map karta hai.

---
**Next Topic:** 20. Production PM2 Cluster Deployment, Memory Leak Profiling (heapdump) & Healthchecks

Loading lesson content...

JavaScript

Full IDE

Live Execution Terminal

Click "Execute Live" to run code.
                

Lesson Mastery AI Quiz

AI Doubt Solver

CERTIFICATE OF COMPLETION

Rishabh Gehlot

PHP 8+ & Laravel 11 Master Track