@remnic/core 9.3.770 → 9.4.0

package/src/logger.test.ts

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { type LoggerBackend, initLogger, log } from "./logger.js";
+
+const FIXED = "2026-07-11T20:00:00.000Z";
+
+function capture(): { lines: string[]; backend: LoggerBackend } {
+  const lines: string[] = [];
+  const push =
+    (level: string) =>
+    (msg: string, ...args: unknown[]) => {
+      lines.push(args.length ? `${level}|${msg}|${JSON.stringify(args)}` : `${level}|${msg}`);
+    };
+  return {
+    lines,
+    backend: {
+      info: push("info"),
+      warn: push("warn"),
+      error: push("error"),
+      debug: push("debug"),
+    },
+  };
+}
+
+const savedEnv = process.env.REMNIC_LOG_TIMESTAMPS;
+test.afterEach(() => {
+  if (savedEnv === undefined) Reflect.deleteProperty(process.env, "REMNIC_LOG_TIMESTAMPS");
+  else process.env.REMNIC_LOG_TIMESTAMPS = savedEnv;
+  // Reset to a silent backend (module default is NOOP) so this suite never
+  // leaks console output or timestamp state into sibling suites in-process.
+  initLogger({ info() {}, warn() {}, error() {}, debug() {} }, false, { timestamps: true });
+});
+
+test("prefixes each level with an ISO 8601 timestamp by default", () => {
+  const { lines, backend } = capture();
+  Reflect.deleteProperty(process.env, "REMNIC_LOG_TIMESTAMPS");
+  initLogger(backend, true, { clock: () => FIXED });
+
+  log.info("hello");
+  log.warn("careful");
+  log.error("boom", new Error("bad"));
+  log.debug("trace");
+
+  assert.deepEqual(lines, [
+    `info|${FIXED} remnic: hello`,
+    `warn|${FIXED} remnic: careful`,
+    `error|${FIXED} remnic: boom — bad`,
+    `debug|${FIXED} remnic [debug]: trace`,
+  ]);
+});
+
+test("timestamps: false restores the legacy 'remnic: ' format", () => {
+  const { lines, backend } = capture();
+  initLogger(backend, false, { timestamps: false, clock: () => FIXED });
+
+  log.info("hello");
+  assert.equal(lines[0], "info|remnic: hello");
+  assert.ok(!lines[0].includes(FIXED));
+});
+
+test("REMNIC_LOG_TIMESTAMPS=false disables the prefix", () => {
+  const { lines, backend } = capture();
+  process.env.REMNIC_LOG_TIMESTAMPS = "false";
+  initLogger(backend, false, { clock: () => FIXED });
+
+  log.info("hello");
+  assert.equal(lines[0], "info|remnic: hello");
+});
+
+test("explicit option overrides the env var", () => {
+  const { lines, backend } = capture();
+  process.env.REMNIC_LOG_TIMESTAMPS = "false";
+  initLogger(backend, false, { timestamps: true, clock: () => FIXED });
+
+  log.info("hello");
+  assert.equal(lines[0], `info|${FIXED} remnic: hello`);
+});
+
+test("emits a real ISO 8601 timestamp when no clock is injected", () => {
+  const { lines, backend } = capture();
+  Reflect.deleteProperty(process.env, "REMNIC_LOG_TIMESTAMPS");
+  initLogger(backend, false);
+
+  log.info("hello");
+  const m = /^info\|(\S+) remnic: hello$/.exec(lines[0]);
+  assert.ok(m, `unexpected line: ${lines[0]}`);
+  assert.ok(!Number.isNaN(Date.parse(m[1])));
+  assert.equal(new Date(m[1]).toISOString(), m[1]);
+});
+
+test("preserves variadic args and gates debug on the debug flag", () => {
+  const { lines, backend } = capture();
+  initLogger(backend, false, { clock: () => FIXED });
+  log.debug("suppressed");
+  assert.equal(lines.length, 0, "debug must be gated when debug=false");
+
+  initLogger(backend, true, { clock: () => FIXED });
+  log.info("withargs", { a: 1 });
+  assert.equal(lines.at(-1), `info|${FIXED} remnic: withargs|[{"a":1}]`);
+});
+
+test("unrecognized REMNIC_LOG_TIMESTAMPS falls through to the default (on)", () => {
+  const { lines, backend } = capture();
+  process.env.REMNIC_LOG_TIMESTAMPS = "maybe";
+  initLogger(backend, false, { clock: () => FIXED });
+
+  log.info("hello");
+  assert.equal(lines[0], `info|${FIXED} remnic: hello`);
+});
+
+test("empty or whitespace-only REMNIC_LOG_TIMESTAMPS reads as unset (default on)", () => {
+  for (const raw of ["", "   "]) {
+    const { lines, backend } = capture();
+    process.env.REMNIC_LOG_TIMESTAMPS = raw;
+    initLogger(backend, false, { clock: () => FIXED });
+    log.info("hello");
+    assert.equal(lines[0], `info|${FIXED} remnic: hello`, `raw=${JSON.stringify(raw)}`);
+  }
+});

package/src/logger.ts

@@ -12,8 +12,29 @@ const NOOP_LOGGER: LoggerBackend = {
   debug() {},
 };
 
+export interface LoggerOptions {
+  /** Prefix each emitted line with an ISO 8601 timestamp. Defaults to true. */
+  timestamps?: boolean;
+  /** Clock source for the timestamp prefix; injectable for tests. */
+  clock?: () => string;
+}
+
 let _backend: LoggerBackend = NOOP_LOGGER;
 let _debug = false;
+let _timestamps = true;
+let _clock: () => string = () => new Date().toISOString();
+
+// Coerce a boolean-like env string. Empty/whitespace-only and unrecognized
+// values return undefined so callers fall through to the default (timestamps
+// on) rather than silently disabling — an empty env var reads as "unset".
+function coerceBool(value: string | undefined): boolean | undefined {
+  if (value === undefined) return undefined;
+  const s = value.trim().toLowerCase();
+  if (s === "") return undefined;
+  if (s === "0" || s === "false" || s === "no" || s === "off") return false;
+  if (s === "1" || s === "true" || s === "yes" || s === "on") return true;
+  return undefined;
+}
 
 // Late-bind console.* rather than capturing references at module import
 // time. In production this is behaviour-identical to the pre-bound
@@ -31,28 +52,35 @@ const CONSOLE_LOGGER: LoggerBackend = {
   debug: (msg, ...args) => console.debug(msg, ...args),
 };
 
-export function initLogger(backend?: LoggerBackend, debug?: boolean): void {
+export function initLogger(backend?: LoggerBackend, debug?: boolean, options?: LoggerOptions): void {
   _backend = backend ?? CONSOLE_LOGGER;
   _debug = debug ?? false;
+  // Precedence: explicit option > REMNIC_LOG_TIMESTAMPS env > default (on).
+  _timestamps = options?.timestamps ?? coerceBool(process.env.REMNIC_LOG_TIMESTAMPS) ?? true;
+  _clock = options?.clock ?? (() => new Date().toISOString());
+}
+
+// Format one log line: "<iso> remnic: <msg>" when timestamps are enabled,
+// otherwise the legacy "remnic: <msg>". Timestamp is per-call.
+function fmt(msg: string, label = "remnic"): string {
+  const ts = _timestamps ? `${_clock()} ` : "";
+  return `${ts}${label}: ${msg}`;
 }
 
 export const log = {
   info(msg: string, ...args: unknown[]): void {
-    _backend.info(`remnic: ${msg}`, ...args);
+    _backend.info(fmt(msg), ...args);
   },
   warn(msg: string, ...args: unknown[]): void {
-    _backend.warn(`remnic: ${msg}`, ...args);
+    _backend.warn(fmt(msg), ...args);
   },
   error(msg: string, err?: unknown): void {
-    const detail =
-      err instanceof Error ? err.message : err ? String(err) : "";
-    _backend.error(
-      `remnic: ${msg}${detail ? ` — ${detail}` : ""}`,
-    );
+    const detail = err instanceof Error ? err.message : err ? String(err) : "";
+    _backend.error(fmt(`${msg}${detail ? ` — ${detail}` : ""}`));
   },
   debug(msg: string, ...args: unknown[]): void {
     if (!_debug) return;
     const fn = _backend.debug ?? _backend.info;
-    fn(`remnic [debug]: ${msg}`, ...args);
+    fn(fmt(msg, "remnic [debug]"), ...args);
   },
 };

package/dist/chunk-NU3CSQ4H.js

@@ -1,48 +0,0 @@
-// src/logger.ts
-var NOOP_LOGGER = {
-  info() {
-  },
-  warn() {
-  },
-  error() {
-  },
-  debug() {
-  }
-};
-var _backend = NOOP_LOGGER;
-var _debug = false;
-var CONSOLE_LOGGER = {
-  info: (msg, ...args) => console.info(msg, ...args),
-  warn: (msg, ...args) => console.warn(msg, ...args),
-  error: (msg, ...args) => console.error(msg, ...args),
-  debug: (msg, ...args) => console.debug(msg, ...args)
-};
-function initLogger(backend, debug) {
-  _backend = backend ?? CONSOLE_LOGGER;
-  _debug = debug ?? false;
-}
-var log = {
-  info(msg, ...args) {
-    _backend.info(`remnic: ${msg}`, ...args);
-  },
-  warn(msg, ...args) {
-    _backend.warn(`remnic: ${msg}`, ...args);
-  },
-  error(msg, err) {
-    const detail = err instanceof Error ? err.message : err ? String(err) : "";
-    _backend.error(
-      `remnic: ${msg}${detail ? ` \u2014 ${detail}` : ""}`
-    );
-  },
-  debug(msg, ...args) {
-    if (!_debug) return;
-    const fn = _backend.debug ?? _backend.info;
-    fn(`remnic [debug]: ${msg}`, ...args);
-  }
-};
-
-export {
-  initLogger,
-  log
-};
-//# sourceMappingURL=chunk-NU3CSQ4H.js.map

package/dist/chunk-NU3CSQ4H.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/logger.ts"],"sourcesContent":["export interface LoggerBackend {\n  info(msg: string, ...args: unknown[]): void;\n  warn(msg: string, ...args: unknown[]): void;\n  error(msg: string, ...args: unknown[]): void;\n  debug?(msg: string, ...args: unknown[]): void;\n}\n\nconst NOOP_LOGGER: LoggerBackend = {\n  info() {},\n  warn() {},\n  error() {},\n  debug() {},\n};\n\nlet _backend: LoggerBackend = NOOP_LOGGER;\nlet _debug = false;\n\n// Late-bind console.* rather than capturing references at module import\n// time. In production this is behaviour-identical to the pre-bound\n// `.bind(console)` form — `console.info(msg, ...)` resolves `this` to\n// `console` whether called directly or via an arrow wrapper — but it lets\n// harnesses that swap console methods (e.g. runCli in @remnic/cli) route\n// logger output through their capture sinks. With the old pre-bound form,\n// any command that called initLogger() pinned the logger to the original\n// console methods before the harness could swap them, so log.warn /\n// log.info output escaped the capture buffer.\nconst CONSOLE_LOGGER: LoggerBackend = {\n  info: (msg, ...args) => console.info(msg, ...args),\n  warn: (msg, ...args) => console.warn(msg, ...args),\n  error: (msg, ...args) => console.error(msg, ...args),\n  debug: (msg, ...args) => console.debug(msg, ...args),\n};\n\nexport function initLogger(backend?: LoggerBackend, debug?: boolean): void {\n  _backend = backend ?? CONSOLE_LOGGER;\n  _debug = debug ?? false;\n}\n\nexport const log = {\n  info(msg: string, ...args: unknown[]): void {\n    _backend.info(`remnic: ${msg}`, ...args);\n  },\n  warn(msg: string, ...args: unknown[]): void {\n    _backend.warn(`remnic: ${msg}`, ...args);\n  },\n  error(msg: string, err?: unknown): void {\n    const detail =\n      err instanceof Error ? err.message : err ? String(err) : \"\";\n    _backend.error(\n      `remnic: ${msg}${detail ? ` — ${detail}` : \"\"}`,\n    );\n  },\n  debug(msg: string, ...args: unknown[]): void {\n    if (!_debug) return;\n    const fn = _backend.debug ?? _backend.info;\n    fn(`remnic [debug]: ${msg}`, ...args);\n  },\n};\n"],"mappings":";AAOA,IAAM,cAA6B;AAAA,EACjC,OAAO;AAAA,EAAC;AAAA,EACR,OAAO;AAAA,EAAC;AAAA,EACR,QAAQ;AAAA,EAAC;AAAA,EACT,QAAQ;AAAA,EAAC;AACX;AAEA,IAAI,WAA0B;AAC9B,IAAI,SAAS;AAWb,IAAM,iBAAgC;AAAA,EACpC,MAAM,CAAC,QAAQ,SAAS,QAAQ,KAAK,KAAK,GAAG,IAAI;AAAA,EACjD,MAAM,CAAC,QAAQ,SAAS,QAAQ,KAAK,KAAK,GAAG,IAAI;AAAA,EACjD,OAAO,CAAC,QAAQ,SAAS,QAAQ,MAAM,KAAK,GAAG,IAAI;AAAA,EACnD,OAAO,CAAC,QAAQ,SAAS,QAAQ,MAAM,KAAK,GAAG,IAAI;AACrD;AAEO,SAAS,WAAW,SAAyB,OAAuB;AACzE,aAAW,WAAW;AACtB,WAAS,SAAS;AACpB;AAEO,IAAM,MAAM;AAAA,EACjB,KAAK,QAAgB,MAAuB;AAC1C,aAAS,KAAK,WAAW,GAAG,IAAI,GAAG,IAAI;AAAA,EACzC;AAAA,EACA,KAAK,QAAgB,MAAuB;AAC1C,aAAS,KAAK,WAAW,GAAG,IAAI,GAAG,IAAI;AAAA,EACzC;AAAA,EACA,MAAM,KAAa,KAAqB;AACtC,UAAM,SACJ,eAAe,QAAQ,IAAI,UAAU,MAAM,OAAO,GAAG,IAAI;AAC3D,aAAS;AAAA,MACP,WAAW,GAAG,GAAG,SAAS,WAAM,MAAM,KAAK,EAAE;AAAA,IAC/C;AAAA,EACF;AAAA,EACA,MAAM,QAAgB,MAAuB;AAC3C,QAAI,CAAC,OAAQ;AACb,UAAM,KAAK,SAAS,SAAS,SAAS;AACtC,OAAG,mBAAmB,GAAG,IAAI,GAAG,IAAI;AAAA,EACtC;AACF;","names":[]}