observe-node 1.0.0 → 1.0.2

package/package.json

@@ -1,11 +1,20 @@
 {
   "name": "observe-node",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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

@@ -2,63 +2,85 @@
 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 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;
+}
+
 
-  // Fallback: originalUrl without querystring
-  const raw = req.originalUrl || req.url || "";
-  return raw.split("?")[0] || raw;
+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}`;
+    }
+
+    // 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();
-
-    // expose id to downstream services
-    res.setHeader("x-request-id", String(requestId));
-
-    const start = process.hrtime.bigint();
-
-    runWithContext({ request_id: String(requestId) }, () => {
-      res.on("finish", () => {
-        const end = process.hrtime.bigint();
-        const durationMs = Number(end - start) / 1_000_000;
-
-        const status = res.statusCode;
-        const level = status >= 500 ? "error" : status >= 400 ? "warn" : "info";
-
-        const path = getRoutePath(req);
-
-        config.emitEvent({
-          event_name: "http.request",
-          level,
-          message: "HTTP request completed",
-          http: {
-            method: req.method,
-            path,
-            status,
-            duration_ms: Math.round(durationMs),
-          },
-        });
+    const config = observe.__config;
+
+    return function observeExpress(req, res, next) {
+        const requestId =
+            req.headers["x-request-id"] ||
+            req.headers["x-correlation-id"] ||
+            newId();
 
-        // metrics hook (if enabled)
-        if (typeof config._observeHttpMetric === "function") {
-          config._observeHttpMetric(req.method, path, status, durationMs);
-        }
-      });
+        // expose id to downstream services
+        res.setHeader("x-request-id", String(requestId));
 
-      next();
-    });
-  };
+        const start = process.hrtime.bigint();
+
+        runWithContext({ request_id: String(requestId) }, () => {
+            res.on("finish", () => {
+                const end = process.hrtime.bigint();
+                const durationMs = Number(end - start) / 1_000_000;
+
+                const status = res.statusCode;
+                const level = status >= 500 ? "error" : status >= 400 ? "warn" : "info";
+
+                const path = getRoutePath(req);
+
+                config.emitEvent({
+                    event_name: "http.request",
+                    level,
+                    message: `${req.method} ${path} -> ${status} (${Math.round(durationMs)}ms)`,
+                    http: {
+                        method: req.method,
+                        path,
+                        original_url: (req.originalUrl || req.url || "").split("?")[0],
+                        status,
+                        duration_ms: Math.round(durationMs),
+                        ip: req.ip,
+                        user_agent: req.headers["user-agent"],
+                    },
+                    request: {
+                        query: req.query,
+                        params: req.params,
+                        // ⚠️ body is optional (see below)
+                       body: redact(req.body),
+                    },
+                });
+
+                // metrics hook (if enabled)
+                if (typeof config._observeHttpMetric === "function") {
+                    config._observeHttpMetric(req.method, path, status, durationMs);
+                }
+            });
+
+            next();
+        });
+    };
 }
 
 module.exports = { expressMiddleware };

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,
 };