observe-node 1.0.0 → 1.0.3

package/package.json

@@ -1,11 +1,20 @@
 {
   "name": "observe-node",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Structured logs + Prometheus metrics SDK for Node.js (Loki/Grafana ready)",
   "main": "src/index.js",
   "type": "commonjs",
-  "files": ["src"],
-  "keywords": ["observability","logging","metrics","prometheus","loki","grafana"],
+  "files": [
+    "src"
+  ],
+  "keywords": [
+    "observability",
+    "logging",
+    "metrics",
+    "prometheus",
+    "loki",
+    "grafana"
+  ],
   "license": "MIT",
   "scripts": {
     "dev": "nodemon example.js"
@@ -17,4 +26,4 @@
   "devDependencies": {
     "nodemon": "^3.1.14"
   }
-}
+}

package/src/http/express.js

@@ -1,63 +1,78 @@
 // src/http/express.js
-const { runWithContext } = require("../utils/context");
-const { newId } = require("../utils/ids");
-
-function getRoutePath(req) {
-  // Prefer express route pattern if available (best for metrics + grouping)
-  if (req.route && req.route.path) {
-    const base = req.baseUrl || "";
-    return `${base}${req.route.path}`;
+function safeJsonSizeBytes(obj) {
+  try {
+    return Buffer.byteLength(JSON.stringify(obj), "utf8");
+  } catch {
+    return null;
   }
-
-  // Fallback: originalUrl without querystring
-  const raw = req.originalUrl || req.url || "";
-  return raw.split("?")[0] || raw;
 }
 
-function expressMiddleware(observe) {
-  const config = observe.__config;
-
-  return function observeExpress(req, res, next) {
-    const requestId =
-      req.headers["x-request-id"] ||
-      req.headers["x-correlation-id"] ||
-      newId();
+function redact(obj, keys = ["password","token","authorization","jwt","otp","secret","accessToken","refreshToken"]) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(v => redact(v, keys));
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    if (keys.includes(k)) out[k] = "[REDACTED]";
+    else out[k] = redact(obj[k], keys);
+  }
+  return out;
+}
 
-    // expose id to downstream services
-    res.setHeader("x-request-id", String(requestId));
+function pickResponseBody(body, maxBytes = 20_000) {
+  // limit response size (avoid huge payloads / images)
+  const redacted = redact(body);
+  const bytes = safeJsonSizeBytes(redacted);
+  if (bytes == null) return { truncated: true, bytes: null };
+  if (bytes > maxBytes) return { truncated: true, bytes };
+  return { body: redacted, truncated: false, bytes };
+}
 
-    const start = process.hrtime.bigint();
+function expressMiddleware(observe, opts = {}) {
+  const maxResponseBytes = Number(opts.maxResponseBytes || 20_000);
 
-    runWithContext({ request_id: String(requestId) }, () => {
-      res.on("finish", () => {
-        const end = process.hrtime.bigint();
-        const durationMs = Number(end - start) / 1_000_000;
+  return function (req, res, next) {
+    const start = Date.now();
 
-        const status = res.statusCode;
-        const level = status >= 500 ? "error" : status >= 400 ? "warn" : "info";
+    // ✅ capture response body
+    let capturedResponse;
+    const _json = res.json.bind(res);
+    res.json = (body) => {
+      capturedResponse = pickResponseBody(body, maxResponseBytes);
+      return _json(body);
+    };
 
-        const path = getRoutePath(req);
+    const _send = res.send.bind(res);
+    res.send = (body) => {
+      // if body is string/buffer, avoid logging full
+      capturedResponse = { truncated: true, bytes: Buffer.isBuffer(body) ? body.length : (typeof body === "string" ? Buffer.byteLength(body) : null) };
+      return _send(body);
+    };
 
-        config.emitEvent({
-          event_name: "http.request",
-          level,
-          message: "HTTP request completed",
-          http: {
-            method: req.method,
-            path,
-            status,
-            duration_ms: Math.round(durationMs),
-          },
-        });
+    res.on("finish", () => {
+      const duration_ms = Date.now() - start;
 
-        // metrics hook (if enabled)
-        if (typeof config._observeHttpMetric === "function") {
-          config._observeHttpMetric(req.method, path, status, durationMs);
-        }
+      observe.emit({
+        event_name: "http.response",
+        level: res.statusCode >= 500 ? "error" : res.statusCode >= 400 ? "warn" : "info",
+        message: `${req.method} ${req.originalUrl} -> ${res.statusCode} (${duration_ms}ms)`,
+        http: {
+          method: req.method,
+          path: (req.originalUrl || req.url || "").split("?")[0],
+          status: res.statusCode,
+          duration_ms,
+        },
+        request: {
+          query: req.query,
+          params: req.params,
+        },
+        response: {
+          status: res.statusCode,
+          ...capturedResponse, // { body?, truncated, bytes }
+        },
       });
-
-      next();
     });
+
+    next();
   };
 }
 

package/src/http/expressError.js

@@ -1,30 +1,39 @@
 // src/http/expressError.js
 function createExpressErrorMiddleware(observe, opts = {}) {
-  const {
-    includeStack = true,
-  } = opts;
+    const {
+        includeStack = true,
+    } = opts;
 
-  // eslint-disable-next-line no-unused-vars
-  return function observeExpressError(err, req, res, next) {
-    const status = err.status || err.statusCode || 500;
+    // eslint-disable-next-line no-unused-vars
+    return function observeExpressError(err, req, res, next) {
+        const status = err.status || err.statusCode || 500;
 
-    // your apps may set these:
-    const code = err.code; // e.g. "AUTH-401" / "WH-INV-001"
+        // your apps may set these:
+        const code = err.code; // e.g. "AUTH-401" / "WH-INV-001"
 
-    observe.emit({
-      event_name: "error",
-      level: "error",
-      message: err.message || "Unhandled error",
-      error: {
-        name: err.name || "Error",
-        code,
-        status,
-        stack: includeStack ? err.stack : undefined,
-      },
-    });
+        observe.emit({
+            event_name: "http.error",
+            level: "error",
+            message: `${req.method} ${req.originalUrl} failed: ${err.message}`,
+            http: {
+                method: req.method,
+                path: (req.originalUrl || req.url || "").split("?")[0],
+            },
+            request: {
+                query: req.query,
+                params: req.params,
+                body: req.body,
+            },
+            error: {
+                name: err.name || "Error",
+                code: err.code,
+                status,
+                stack: includeStack ? err.stack : undefined,
+            },
+        });
 
-    next(err);
-  };
+        next(err);
+    };
 }
 
 module.exports = { createExpressErrorMiddleware };

package/src/index.js

@@ -1,8 +1,10 @@
 // src/index.js
 const start = require("./start");
 const { expressMiddleware } = require("./http/express");
+const { createExpressErrorMiddleware } = require("./http/expressError");
 
 module.exports = {
   start,
   expressMiddleware,
+  createExpressErrorMiddleware,
 };