@blamejs/core 0.4.11 → 0.4.12

package/CHANGELOG.md

@@ -8,6 +8,7 @@ upgrading across more than a few patches at a time.
 
 ## v0.4.x
 
+- **0.4.11** (2026-04-30) — b.cache: bytes-cap eviction, sliding TTL, tag invalidation
 - **0.4.10** (2026-04-30) — bodyParser multipart: fileFilter + per-field maxBytes/mimeTypes
 - **0.4.9** (2026-04-30) — Origin-Agent-Cluster + DNS-Prefetch-Control headers; b.auth.lockout primitive
 - **0.4.8** (2026-04-30) — wiki SEO surface: per-page OG / Twitter / JSON-LD + sitemap.xml + robots.txt

package/lib/log.js

@@ -9,7 +9,8 @@
  *
  * Each line is one JSON object on a single line, terminated with `\n`.
  * Levels: debug (0) < info (1) < warn (2) < error (3) < fatal (4).
- * info-and-below routes to stdout; warn-and-up routes to stderr.
+ * Default routing: debug / info / warn → stdout; error / fatal → stderr.
+ * Multi-sink config (`sinks: [...]`) takes full control of routing.
  *
  *   var log = b.log.create({
  *     level:   "info",            // env LOG_LEVEL > opts.level > "info"
@@ -17,6 +18,19 @@
  *     redact:  true,              // run extras through lib/redact
  *   });
  *
+ *   // Multi-sink: each sink gets every line at-or-above its own level.
+ *   // Default (no `sinks` opt) splits info-and-below to stdout and
+ *   // warn-and-up to stderr — same as before.
+ *   var log = b.log.create({
+ *     level: "debug",
+ *     sinks: [
+ *       { stream: process.stdout,                              level: "info"  },
+ *       { stream: fs.createWriteStream("./logs/debug.log"),    level: "debug" },
+ *       { stream: fs.createWriteStream("./logs/errors.log"),   level: "error" },
+ *     ],
+ *   });
+ *   // sinks: [...] is mutually exclusive with destination/errorDestination.
+ *
  *   log.info("user logged in", { userId: "u-1" });
  *   log.error("payment failed", { orderId, err: e.message });
  *
@@ -116,10 +130,56 @@ function _mergeExtras(into, extras, redactExtras) {
   return clobberAttempt;
 }
 
+function _resolveSinks(opts) {
+  // Three input shapes — pick exactly one:
+  //   (a) opts.sinks: [{ stream, level }, ...]
+  //   (b) opts.destination + opts.errorDestination (legacy two-sink split)
+  //   (c) neither — defaults to stdout for info-and-below, stderr for warn-and-up
+  if (Array.isArray(opts.sinks)) {
+    if (opts.destination !== undefined || opts.errorDestination !== undefined) {
+      throw new LogError("log/conflicting-sinks",
+        "log.create: pass either { sinks: [...] } OR { destination, errorDestination }, not both");
+    }
+    if (opts.sinks.length === 0) {
+      throw new LogError("log/no-sinks",
+        "log.create: sinks: [] would silently drop every line — pass at least one sink");
+    }
+    return opts.sinks.map(function (s, i) {
+      if (!s || typeof s !== "object") {
+        throw new LogError("log/bad-sink", "sinks[" + i + "]: expected object with { stream, level? }");
+      }
+      var allowed = ["stream", "level"];
+      var keys = Object.keys(s);
+      for (var j = 0; j < keys.length; j++) {
+        if (allowed.indexOf(keys[j]) === -1) {
+          throw new LogError("log/bad-sink",
+            "sinks[" + i + "]: unknown key '" + keys[j] + "' (allowed: " + allowed.join(", ") + ")");
+        }
+      }
+      var stream = _normalizeDestination(s.stream, null);
+      if (!stream) {
+        throw new LogError("log/bad-sink", "sinks[" + i + "]: stream is required");
+      }
+      // Per-sink level: missing → no filter beyond the global; present → must be valid.
+      var minLevel = (s.level === undefined) ? null : _normalizeLevel(s.level);
+      return { stream: stream, minLevel: minLevel };
+    });
+  }
+  // Legacy / default — synthesize the two-sink split.
+  var stdoutDest = _normalizeDestination(opts.destination, process.stdout);
+  var stderrDest = _normalizeDestination(opts.errorDestination, process.stderr);
+  return [
+    // Order matters for emit fan-out: stdout sink catches debug-info-warn;
+    // stderr catches error-and-up. Existing behavior — same boundary.
+    { stream: stdoutDest, minLevel: null, _maxLevelExclusive: LEVELS.error },
+    { stream: stderrDest, minLevel: LEVELS.error },
+  ];
+}
+
 function create(opts) {
   opts = opts || {};
   validateOpts(opts, [
-    "level", "destination", "errorDestination",
+    "level", "destination", "errorDestination", "sinks",
     "format", "redact", "base", "clock",
   ], "b.log");
 
@@ -134,8 +194,7 @@ function create(opts) {
     level = LEVELS.info;
   }
 
-  var stdoutDest = _normalizeDestination(opts.destination, process.stdout);
-  var stderrDest = _normalizeDestination(opts.errorDestination, process.stderr);
+  var sinks = _resolveSinks(opts);
 
   var format    = opts.format || "json"; // reserved for future formats
   if (format !== "json") {
@@ -197,9 +256,16 @@ function create(opts) {
       }) + "\n";
     }
 
-    var dest = (LEVELS[levelName] >= LEVELS.error) ? stderrDest : stdoutDest;
-    try { dest.write(line); }
-    catch (_e) { /* destination write best-effort — never throw out of a log call */ }
+    var lvlNum = LEVELS[levelName];
+    for (var s = 0; s < sinks.length; s++) {
+      var sink = sinks[s];
+      if (sink.minLevel !== null && lvlNum < sink.minLevel) continue;
+      // Legacy default-sinks split uses an exclusive upper bound so the
+      // stdout sink catches only info-and-below (warn+ goes to stderr).
+      if (sink._maxLevelExclusive !== undefined && lvlNum >= sink._maxLevelExclusive) continue;
+      try { sink.stream.write(line); }
+      catch (_e) { /* sink write best-effort — never throw out of a log call */ }
+    }
   }
 
   function _makeInstance(boundChain) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.4.11",
+  "version": "0.4.12",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",