@blamejs/core 0.7.18 → 0.7.20

package/lib/middleware/request-id.js

@@ -1,61 +1,61 @@
-"use strict";
-/**
- * Request-ID middleware. Propagates an existing X-Request-Id header (or
- * trace ID from upstream) when present and well-formed; otherwise
- * generates a fresh 32-hex value. Sets req.requestId AND emits the same
- * value as a response header so downstream services + auditors can
- * correlate.
- *
- * Threading the request ID into audit.record() metadata is what makes
- * the cross-event correlation traceable; apps should pass this through
- * to every audit.record() they call within the request lifecycle.
- *
- * Options:
- *   {
- *     headerName:    'X-Request-Id'
- *     trustUpstream: true         // propagate upstream id if it matches
- *                                 //   the format check; false → always
- *                                 //   generate fresh
- *     formatRegex:   /^[A-Za-z0-9._-]{8,128}$/
- *   }
- */
-var C = require("../constants");
-var { generateToken } = require("../crypto");
-var validateOpts = require("../validate-opts");
-
-var DEFAULT_FORMAT = /^[A-Za-z0-9._-]{8,128}$/;
-// Hard cap on inbound header length. The DEFAULT_FORMAT regex caps at
-// 128 chars, but operator-supplied formatRegex values may be looser;
-// length-bound the candidate before .test() so a multi-megabyte header
-// can't drive ReDoS even against a careless operator pattern.
-var MAX_INBOUND_LEN = C.BYTES.bytes(256);
-
-function create(opts) {
-  opts = opts || {};
-  validateOpts(opts, [
-    "headerName", "trustUpstream", "formatRegex",
-  ], "middleware.requestId");
-  var headerName = (opts.headerName || "X-Request-Id");
-  var headerNameLower = headerName.toLowerCase();
-  var trustUpstream = opts.trustUpstream !== false;
-  var format = opts.formatRegex || DEFAULT_FORMAT;
-
-  return function requestId(req, res, next) {
-    var inbound = req.headers && req.headers[headerNameLower];
-    var id;
-    if (trustUpstream && typeof inbound === "string" &&
-        inbound.length > 0 && inbound.length <= MAX_INBOUND_LEN &&
-        format.test(inbound)) {
-      id = inbound;
-    } else {
-      id = generateToken(C.BYTES.bytes(16));  // 32 hex chars
-    }
-    req.requestId = id;
-    if (typeof res.setHeader === "function") {
-      res.setHeader(headerName, id);
-    }
-    next();
-  };
-}
-
-module.exports = { create: create };
+"use strict";
+/**
+ * Request-ID middleware. Propagates an existing X-Request-Id header (or
+ * trace ID from upstream) when present and well-formed; otherwise
+ * generates a fresh 32-hex value. Sets req.requestId AND emits the same
+ * value as a response header so downstream services + auditors can
+ * correlate.
+ *
+ * Threading the request ID into audit.record() metadata is what makes
+ * the cross-event correlation traceable; apps should pass this through
+ * to every audit.record() they call within the request lifecycle.
+ *
+ * Options:
+ *   {
+ *     headerName:    'X-Request-Id'
+ *     trustUpstream: true         // propagate upstream id if it matches
+ *                                 //   the format check; false → always
+ *                                 //   generate fresh
+ *     formatRegex:   /^[A-Za-z0-9._-]{8,128}$/
+ *   }
+ */
+var C = require("../constants");
+var { generateToken } = require("../crypto");
+var validateOpts = require("../validate-opts");
+
+var DEFAULT_FORMAT = /^[A-Za-z0-9._-]{8,128}$/;
+// Hard cap on inbound header length. The DEFAULT_FORMAT regex caps at
+// 128 chars, but operator-supplied formatRegex values may be looser;
+// length-bound the candidate before .test() so a multi-megabyte header
+// can't drive ReDoS even against a careless operator pattern.
+var MAX_INBOUND_LEN = C.BYTES.bytes(256);
+
+function create(opts) {
+  opts = opts || {};
+  validateOpts(opts, [
+    "headerName", "trustUpstream", "formatRegex",
+  ], "middleware.requestId");
+  var headerName = (opts.headerName || "X-Request-Id");
+  var headerNameLower = headerName.toLowerCase();
+  var trustUpstream = opts.trustUpstream !== false;
+  var format = opts.formatRegex || DEFAULT_FORMAT;
+
+  return function requestId(req, res, next) {
+    var inbound = req.headers && req.headers[headerNameLower];
+    var id;
+    if (trustUpstream && typeof inbound === "string" &&
+        inbound.length > 0 && inbound.length <= MAX_INBOUND_LEN &&
+        format.test(inbound)) {
+      id = inbound;
+    } else {
+      id = generateToken(C.BYTES.bytes(16));  // 32 hex chars
+    }
+    req.requestId = id;
+    if (typeof res.setHeader === "function") {
+      res.setHeader(headerName, id);
+    }
+    next();
+  };
+}
+
+module.exports = { create: create };

package/lib/middleware/request-log.js

@@ -1,168 +1,168 @@
-"use strict";
-/**
- * request-log — HTTP access-log middleware. Captures method, path,
- * status, duration, response bytes, requestId, actor IP, user-agent
- * and emits one structured log entry per request via b.log.
- *
- *   router.use(b.middleware.requestLog({
- *     logger:        b.log.boot("http"),     // any b.log instance
- *     skipPaths:     ["/healthz", /^\/static/],
- *     trustProxy:    true,                   // honors X-Forwarded-For
- *     levelFn:       function (status) {     // default: 5xx=error, 4xx=warn, else info
- *       return status >= 500 ? "error" : status >= 400 ? "warn" : "info";
- *     },
- *     fields:        ["method", "path", "status", "durationMs",
- *                     "actorIp", "userAgent", "requestId", "bytes"],
- *   }));
- *
- * The middleware adopts `b.requestHelpers.captureResponseStatus` to
- * read the final status reliably (handlers that call `res.writeHead`
- * vs `res.statusCode = ...` vs `res.status(...).send(...)` all work).
- *
- * trustProxy gates X-Forwarded-For consumption — same boundary as the
- * rest of the framework. Default false; operators behind a sanitizing
- * reverse proxy opt in.
- *
- * Emits at log-level keyed off response status by default. Operators
- * who want one-level-fits-all pass a static string for `level` (e.g.
- * "debug" to keep access logs out of production stdout) or a function
- * for fully custom logic (e.g. "warn" only on slow-path requests).
- */
-var C = require("../constants");
-var requestHelpers = require("../request-helpers");
-var validateOpts = require("../validate-opts");
-
-var DEFAULT_FIELDS = [
-  "method", "path", "status", "durationMs", "bytes",
-  "actorIp", "userAgent", "requestId",
-];
-
-function _defaultLevel(status) {
-  if (status >= 500) return "error";
-  if (status >= 400) return "warn";
-  return "info";
-}
-
-function create(opts) {
-  opts = opts || {};
-  validateOpts(opts, [
-    "logger", "skipPaths", "trustProxy", "level", "levelFn", "fields",
-  ], "middleware.requestLog");
-  var logger = opts.logger;
-  if (!logger || typeof logger.info !== "function") {
-    throw new Error("middleware.requestLog: opts.logger must be a b.log instance " +
-      "(call b.log.boot(...) or b.log.create({...}))");
-  }
-  var skipPaths = Array.isArray(opts.skipPaths) ? opts.skipPaths.slice() : [];
-  for (var i = 0; i < skipPaths.length; i++) {
-    if (typeof skipPaths[i] !== "string" && !(skipPaths[i] instanceof RegExp)) {
-      throw new Error("middleware.requestLog: skipPaths[" + i + "] must be a string prefix or RegExp");
-    }
-  }
-  var trustProxy = opts.trustProxy === true || typeof opts.trustProxy === "number"
-    ? opts.trustProxy : false;
-  var levelFn;
-  if (typeof opts.levelFn === "function") {
-    levelFn = opts.levelFn;
-  } else if (typeof opts.level === "string") {
-    var fixedLevel = opts.level;
-    levelFn = function () { return fixedLevel; };
-  } else {
-    levelFn = _defaultLevel;
-  }
-  var fields = Array.isArray(opts.fields) && opts.fields.length > 0
-    ? opts.fields.slice()
-    : DEFAULT_FIELDS;
-
-  function _shouldSkip(req) {
-    var path = req.pathname || (req.url || "").split("?")[0];
-    for (var i = 0; i < skipPaths.length; i++) {
-      var entry = skipPaths[i];
-      if (typeof entry === "string") { if (path.indexOf(entry) === 0) return true; }
-      else if (entry.test(path)) return true;
-    }
-    return false;
-  }
-
-  return function requestLog(req, res, next) {
-    if (_shouldSkip(req)) return next();
-    var startedAt = process.hrtime ? process.hrtime() : null;
-    var startedMs = Date.now();
-    var bytes = 0;
-    var statusFromWriteHead = null;
-    var emitted = false;
-
-    // Tally bytes off res.write / res.end and read the final status
-    // when end fires. Inlined here (rather than composing
-    // captureResponseStatus + a separate byte-counter) so the log
-    // entry sees the fully-populated bytes counter — wrap order
-    // matters: bytes must be incremented BEFORE the log emit.
-    var origWrite     = res.write;
-    var origEnd       = res.end;
-    var origWriteHead = res.writeHead;
-    res.writeHead = function (s) {
-      statusFromWriteHead = s;
-      return origWriteHead.apply(res, arguments);
-    };
-    res.write = function (chunk, enc, cb) {
-      if (chunk != null) {
-        var len = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(String(chunk), enc || "utf8");
-        bytes += len;
-      }
-      return origWrite.call(res, chunk, enc, cb);
-    };
-    res.end = function (chunk, enc, cb) {
-      if (chunk != null) {
-        var len = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(String(chunk), enc || "utf8");
-        bytes += len;
-      }
-      _emit();
-      return origEnd.call(res, chunk, enc, cb);
-    };
-
-    function _emit() {
-      if (emitted) return;
-      emitted = true;
-      var statusCode = statusFromWriteHead != null
-        ? statusFromWriteHead
-        : (typeof res.statusCode === "number" ? res.statusCode : requestHelpers.HTTP_STATUS.OK);
-      var durationMs;
-      if (startedAt && process.hrtime) {
-        var d = process.hrtime(startedAt);
-        durationMs = C.TIME.seconds(d[0]) + (d[1] / 1e6);
-      } else {
-        durationMs = Date.now() - startedMs;
-      }
-      var entry = {};
-      var actor = requestHelpers.extractActorContext(req, {
-        ip: requestHelpers.clientIp(req, { trustProxy: trustProxy }),
-      });
-      var src = {
-        method:     req.method,
-        path:       req.pathname || (req.url || "").split("?")[0],
-        status:     statusCode,
-        durationMs: Math.round(durationMs * 100) / 100,
-        bytes:      bytes,
-        actorIp:    actor.ip,
-        userAgent:  actor.userAgent,
-        requestId:  actor.requestId,
-        sessionId:  actor.sessionId,
-        userId:     actor.userId,
-        route:      actor.route,
-      };
-      for (var fi = 0; fi < fields.length; fi++) {
-        var f = fields[fi];
-        if (Object.prototype.hasOwnProperty.call(src, f)) entry[f] = src[f];
-      }
-      var level = levelFn(statusCode, req, res);
-      var fn = typeof logger[level] === "function" ? logger[level] : logger.info;
-      try { fn.call(logger, "http", entry); } catch (_e) { /* never let log-emit failure crash the response */ }
-    }
-
-    return next();
-  };
-}
-
-module.exports = {
-  create: create,
-};
+"use strict";
+/**
+ * request-log — HTTP access-log middleware. Captures method, path,
+ * status, duration, response bytes, requestId, actor IP, user-agent
+ * and emits one structured log entry per request via b.log.
+ *
+ *   router.use(b.middleware.requestLog({
+ *     logger:        b.log.boot("http"),     // any b.log instance
+ *     skipPaths:     ["/healthz", /^\/static/],
+ *     trustProxy:    true,                   // honors X-Forwarded-For
+ *     levelFn:       function (status) {     // default: 5xx=error, 4xx=warn, else info
+ *       return status >= 500 ? "error" : status >= 400 ? "warn" : "info";
+ *     },
+ *     fields:        ["method", "path", "status", "durationMs",
+ *                     "actorIp", "userAgent", "requestId", "bytes"],
+ *   }));
+ *
+ * The middleware adopts `b.requestHelpers.captureResponseStatus` to
+ * read the final status reliably (handlers that call `res.writeHead`
+ * vs `res.statusCode = ...` vs `res.status(...).send(...)` all work).
+ *
+ * trustProxy gates X-Forwarded-For consumption — same boundary as the
+ * rest of the framework. Default false; operators behind a sanitizing
+ * reverse proxy opt in.
+ *
+ * Emits at log-level keyed off response status by default. Operators
+ * who want one-level-fits-all pass a static string for `level` (e.g.
+ * "debug" to keep access logs out of production stdout) or a function
+ * for fully custom logic (e.g. "warn" only on slow-path requests).
+ */
+var C = require("../constants");
+var requestHelpers = require("../request-helpers");
+var validateOpts = require("../validate-opts");
+
+var DEFAULT_FIELDS = [
+  "method", "path", "status", "durationMs", "bytes",
+  "actorIp", "userAgent", "requestId",
+];
+
+function _defaultLevel(status) {
+  if (status >= 500) return "error";
+  if (status >= 400) return "warn";
+  return "info";
+}
+
+function create(opts) {
+  opts = opts || {};
+  validateOpts(opts, [
+    "logger", "skipPaths", "trustProxy", "level", "levelFn", "fields",
+  ], "middleware.requestLog");
+  var logger = opts.logger;
+  if (!logger || typeof logger.info !== "function") {
+    throw new Error("middleware.requestLog: opts.logger must be a b.log instance " +
+      "(call b.log.boot(...) or b.log.create({...}))");
+  }
+  var skipPaths = Array.isArray(opts.skipPaths) ? opts.skipPaths.slice() : [];
+  for (var i = 0; i < skipPaths.length; i++) {
+    if (typeof skipPaths[i] !== "string" && !(skipPaths[i] instanceof RegExp)) {
+      throw new Error("middleware.requestLog: skipPaths[" + i + "] must be a string prefix or RegExp");
+    }
+  }
+  var trustProxy = opts.trustProxy === true || typeof opts.trustProxy === "number"
+    ? opts.trustProxy : false;
+  var levelFn;
+  if (typeof opts.levelFn === "function") {
+    levelFn = opts.levelFn;
+  } else if (typeof opts.level === "string") {
+    var fixedLevel = opts.level;
+    levelFn = function () { return fixedLevel; };
+  } else {
+    levelFn = _defaultLevel;
+  }
+  var fields = Array.isArray(opts.fields) && opts.fields.length > 0
+    ? opts.fields.slice()
+    : DEFAULT_FIELDS;
+
+  function _shouldSkip(req) {
+    var path = req.pathname || (req.url || "").split("?")[0];
+    for (var i = 0; i < skipPaths.length; i++) {
+      var entry = skipPaths[i];
+      if (typeof entry === "string") { if (path.indexOf(entry) === 0) return true; }
+      else if (entry.test(path)) return true;
+    }
+    return false;
+  }
+
+  return function requestLog(req, res, next) {
+    if (_shouldSkip(req)) return next();
+    var startedAt = process.hrtime ? process.hrtime() : null;
+    var startedMs = Date.now();
+    var bytes = 0;
+    var statusFromWriteHead = null;
+    var emitted = false;
+
+    // Tally bytes off res.write / res.end and read the final status
+    // when end fires. Inlined here (rather than composing
+    // captureResponseStatus + a separate byte-counter) so the log
+    // entry sees the fully-populated bytes counter — wrap order
+    // matters: bytes must be incremented BEFORE the log emit.
+    var origWrite     = res.write;
+    var origEnd       = res.end;
+    var origWriteHead = res.writeHead;
+    res.writeHead = function (s) {
+      statusFromWriteHead = s;
+      return origWriteHead.apply(res, arguments);
+    };
+    res.write = function (chunk, enc, cb) {
+      if (chunk != null) {
+        var len = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(String(chunk), enc || "utf8");
+        bytes += len;
+      }
+      return origWrite.call(res, chunk, enc, cb);
+    };
+    res.end = function (chunk, enc, cb) {
+      if (chunk != null) {
+        var len = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(String(chunk), enc || "utf8");
+        bytes += len;
+      }
+      _emit();
+      return origEnd.call(res, chunk, enc, cb);
+    };
+
+    function _emit() {
+      if (emitted) return;
+      emitted = true;
+      var statusCode = statusFromWriteHead != null
+        ? statusFromWriteHead
+        : (typeof res.statusCode === "number" ? res.statusCode : requestHelpers.HTTP_STATUS.OK);
+      var durationMs;
+      if (startedAt && process.hrtime) {
+        var d = process.hrtime(startedAt);
+        durationMs = C.TIME.seconds(d[0]) + (d[1] / 1e6);
+      } else {
+        durationMs = Date.now() - startedMs;
+      }
+      var entry = {};
+      var actor = requestHelpers.extractActorContext(req, {
+        ip: requestHelpers.clientIp(req, { trustProxy: trustProxy }),
+      });
+      var src = {
+        method:     req.method,
+        path:       req.pathname || (req.url || "").split("?")[0],
+        status:     statusCode,
+        durationMs: Math.round(durationMs * 100) / 100,
+        bytes:      bytes,
+        actorIp:    actor.ip,
+        userAgent:  actor.userAgent,
+        requestId:  actor.requestId,
+        sessionId:  actor.sessionId,
+        userId:     actor.userId,
+        route:      actor.route,
+      };
+      for (var fi = 0; fi < fields.length; fi++) {
+        var f = fields[fi];
+        if (Object.prototype.hasOwnProperty.call(src, f)) entry[f] = src[f];
+      }
+      var level = levelFn(statusCode, req, res);
+      var fn = typeof logger[level] === "function" ? logger[level] : logger.info;
+      try { fn.call(logger, "http", entry); } catch (_e) { /* never let log-emit failure crash the response */ }
+    }
+
+    return next();
+  };
+}
+
+module.exports = {
+  create: create,
+};