@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-WBPVKEEE.js

@@ -0,0 +1,227 @@
+import {
+  color,
+  writeErr
+} from "./chunk-4VWO3ZXL.js";
+
+// src/infrastructure/logger.ts
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+var LEVEL_RANK = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var COLORS = {
+  error: color.red,
+  warn: color.yellow,
+  info: color.cyan,
+  debug: color.gray,
+  trace: color.dim
+};
+var LOG_LEVELS = /* @__PURE__ */ new Set(["error", "warn", "info", "debug", "trace"]);
+var LOG_FORMATS = /* @__PURE__ */ new Set(["pretty", "json"]);
+var DefaultLogger = class _DefaultLogger {
+  /** How many file writes between rotation size checks (statSync is not free). */
+  static ROTATE_CHECK_EVERY = 100;
+  static MAX_PENDING_FILE_WRITES = 2e3;
+  static MAX_PENDING_FILE_BYTES = 8 * 1024 * 1024;
+  level;
+  file;
+  bindings;
+  format;
+  stderr;
+  maxFileBytes;
+  writesSinceRotateCheck = 0;
+  /**
+   * Serialized async tail for file writes. Every appendFile (and any
+   * chained rotation) is awaited through this promise so file I/O
+   * never overlaps itself — preserving the per-line ordering the
+   * sync version had, but without blocking the caller thread. Any
+   * rejection is swallowed (`catch(() => {})`) because logging must
+   * never crash the host.
+   *
+   * Children share the parent's tail: `child.tail === parent.tail`
+   * for the lifetime of the chain. Read/write access goes through
+   * `_tail` so that, when a child has been wired to a parent, both
+   * `enqueueRotate` and `log` always observe the parent's current tail
+   * rather than a stale snapshot taken at `child()` time.
+   */
+  tail = Promise.resolve();
+  parent = null;
+  pendingFileWrites = 0;
+  pendingFileBytes = 0;
+  get root() {
+    return this.parent ? this.parent.root : this;
+  }
+  /**
+   * Resolve the current tail. For the root logger this is the field;
+   * for a child logger we always read through the parent so that a
+   * child's appends land on the parent's most recent tail, and a
+   * parent's `flush()` waits for everything the child chained.
+   */
+  get _tail() {
+    return this.parent ? this.parent._tail : this.tail;
+  }
+  set _tail(next) {
+    if (this.parent) this.parent.tail = next;
+    else this.tail = next;
+  }
+  constructor(opts = {}) {
+    this.level = opts.level ?? parseLogLevel(process.env.WRONGSTACK_LOG_LEVEL);
+    this.file = opts.file;
+    this.bindings = opts.bindings ?? {};
+    this.format = opts.format ?? parseLogFormat(process.env.WRONGSTACK_LOG_FORMAT);
+    this.stderr = opts.stderr !== false;
+    this.maxFileBytes = opts.maxFileBytes ?? 10 * 1024 * 1024;
+    if (this.file) {
+      const dir = path.dirname(this.file);
+      this._tail = this._tail.then(async () => {
+        await fsp.mkdir(dir, { recursive: true });
+      }).catch(() => void 0);
+    }
+  }
+  error(msg, ctx) {
+    this.log("error", msg, ctx);
+  }
+  warn(msg, ctx) {
+    this.log("warn", msg, ctx);
+  }
+  info(msg, ctx) {
+    this.log("info", msg, ctx);
+  }
+  debug(msg, ctx) {
+    this.log("debug", msg, ctx);
+  }
+  trace(msg, ctx) {
+    this.log("trace", msg, ctx);
+  }
+  child(bindings) {
+    const child = Object.create(_DefaultLogger.prototype);
+    child.level = this.level;
+    child.file = this.file;
+    child.bindings = { ...this.bindings, ...bindings };
+    child.format = this.format;
+    child.stderr = this.stderr;
+    child.maxFileBytes = this.maxFileBytes;
+    child.parent = this;
+    child.writesSinceRotateCheck = this.writesSinceRotateCheck;
+    return child;
+  }
+  /**
+   * Wait until all queued file writes (and any pending rotation) have
+   * completed. `log()` is fire-and-forget by design — the caller never
+   * blocks on disk — so tests, shutdown handlers, and processes that
+   * need a deterministic "everything is on disk now" guarantee should
+   * `await logger.flush()` before reading the file or exiting.
+   */
+  flush() {
+    return this._tail;
+  }
+  /**
+   * Size-based rotation: when the file outgrows `maxFileBytes`, rename it to
+   * `<file>.1` (dropping the previous `.1`) so the live file restarts empty.
+   * Checked on the first write and every ROTATE_CHECK_EVERY writes after.
+   * Best-effort: a rename can fail on Windows while another process holds
+   * the file — the next check retries. Multiple processes appending to the
+   * same log all run this check; whoever crosses the threshold first wins.
+   *
+   * Async: the rotation runs on the file-write tail (so its writes don't
+   * interleave with the next append), and the caller never blocks on a
+   * statSync / renameSync syscall on the hot log path.
+   */
+  enqueueRotate(file) {
+    if (this.writesSinceRotateCheck++ % _DefaultLogger.ROTATE_CHECK_EVERY !== 0) return;
+    this._tail = this._tail.then(async () => {
+      let st;
+      try {
+        st = await fsp.stat(file);
+      } catch {
+        return;
+      }
+      if (st.size < this.maxFileBytes) return;
+      try {
+        await fsp.rm(`${file}.1`, { force: true });
+        await fsp.rename(file, `${file}.1`);
+      } catch {
+      }
+    }).catch(() => void 0);
+  }
+  log(level, msg, ctx) {
+    const r = LEVEL_RANK[level];
+    const allowed = LEVEL_RANK[this.level];
+    if (r > allowed) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = { ts, level, msg, ...this.bindings };
+    if (ctx !== void 0) {
+      entry.ctx = ctx instanceof Error ? { message: ctx.message, stack: ctx.stack } : ctx;
+    }
+    if (this.file) {
+      const line = `${JSON.stringify(entry)}
+`;
+      const bytes = Buffer.byteLength(line, "utf8");
+      const root = this.root;
+      if (root.pendingFileWrites < _DefaultLogger.MAX_PENDING_FILE_WRITES && bytes <= _DefaultLogger.MAX_PENDING_FILE_BYTES && root.pendingFileBytes + bytes <= _DefaultLogger.MAX_PENDING_FILE_BYTES) {
+        root.pendingFileWrites += 1;
+        root.pendingFileBytes += bytes;
+        this.enqueueRotate(this.file);
+        this._tail = this._tail.then(() => fsp.appendFile(this.file, line, { mode: 384 })).catch(() => void 0).finally(() => {
+          root.pendingFileWrites = Math.max(0, root.pendingFileWrites - 1);
+          root.pendingFileBytes = Math.max(0, root.pendingFileBytes - bytes);
+        });
+      }
+    }
+    if (!this.stderr) return;
+    if (this.format === "json") {
+      writeErr(`${JSON.stringify(entry)}
+`);
+    } else {
+      const head = `${color.dim(ts)} ${COLORS[level](level.toUpperCase().padEnd(5))} ${msg}`;
+      if (ctx !== void 0) {
+        writeErr(`${head} ${formatCtx(ctx)}
+`);
+      } else {
+        writeErr(`${head}
+`);
+      }
+    }
+  }
+};
+function parseLogLevel(raw) {
+  return raw && LOG_LEVELS.has(raw) ? raw : "info";
+}
+function parseLogFormat(raw) {
+  return raw && LOG_FORMATS.has(raw) ? raw : "pretty";
+}
+function formatCtx(ctx) {
+  if (ctx instanceof Error) return color.dim(ctx.message);
+  if (typeof ctx === "string") return color.dim(ctx);
+  try {
+    return color.dim(JSON.stringify(ctx));
+  } catch {
+    return color.dim(String(ctx));
+  }
+}
+var noOpLogger = {
+  // 'error' is the quietest level the Logger contract offers; the methods
+  // discard everything regardless, this only matters to level checks.
+  level: "error",
+  error: () => {
+  },
+  warn: () => {
+  },
+  info: () => {
+  },
+  debug: () => {
+  },
+  trace: () => {
+  },
+  child: () => noOpLogger
+};
+
+export {
+  DefaultLogger,
+  noOpLogger
+};
+//# sourceMappingURL=chunk-WBPVKEEE.js.map