@rawnodes/logger 2.7.0 → 2.7.2

package/dist/index.mjs

@@ -4,7 +4,6 @@ import { AsyncLocalStorage } from 'async_hooks';
 import { Transform, Writable } from 'stream';
 import { mkdir } from 'fs/promises';
 import { createStream } from 'rotating-file-stream';
-import { EventEmitter } from 'events';
 import { CloudWatchLogsClient, PutLogEventsCommand, CreateLogGroupCommand, CreateLogStreamCommand, DescribeLogStreamsCommand } from '@aws-sdk/client-cloudwatch-logs';
 import { randomUUID } from 'crypto';
 import { z } from 'zod';
@@ -50,8 +49,24 @@ var MessageBuffer = class {
   timer = null;
   flushing = false;
   closed = false;
+  droppedCount = 0;
   add(message) {
     if (this.closed) return;
+    const limit = this.options.maxQueueSize;
+    if (limit !== void 0 && this.queue.length >= limit) {
+      const policy = this.options.dropPolicy ?? "drop-oldest";
+      const dropped = policy === "drop-oldest" ? [this.queue.shift()] : [message];
+      this.droppedCount += 1;
+      if (this.options.onDrop) {
+        try {
+          this.options.onDrop(dropped);
+        } catch {
+        }
+      }
+      if (policy === "drop-newest") {
+        return;
+      }
+    }
     this.queue.push(message);
     if (this.queue.length >= this.options.batchSize) {
       void this.flush();
@@ -75,13 +90,34 @@ var MessageBuffer = class {
       }
     }
   }
-  async close() {
+  /**
+   * Stops accepting new messages and attempts to flush what's already buffered.
+   * Returns when the queue is drained OR when `timeoutMs` elapses. A timeout
+   * is essential during graceful shutdown — without it, a dead transport would
+   * block process exit indefinitely, and orchestrators like Kubernetes would
+   * escalate to SIGKILL after their grace period.
+   *
+   * Default timeout: 5 seconds. Pass `Infinity` to preserve legacy behaviour.
+   */
+  async close(timeoutMs = 5e3) {
     this.closed = true;
     this.clearTimer();
+    const deadline = timeoutMs === Infinity ? Infinity : Date.now() + timeoutMs;
     while (this.queue.length > 0) {
+      if (Date.now() >= deadline) {
+        return;
+      }
       await this.flush();
     }
   }
+  /** Current number of messages waiting in the queue. */
+  get size() {
+    return this.queue.length;
+  }
+  /** Total number of messages dropped due to queue overflow since creation. */
+  get droppedTotal() {
+    return this.droppedCount;
+  }
   scheduleFlush() {
     if (this.timer || this.closed) return;
     this.timer = setTimeout(() => {
@@ -122,15 +158,19 @@ var DEFAULT_OPTIONS = {
   maxRetries: 3,
   retryDelay: 1e3
 };
-var BaseHttpTransport = class extends EventEmitter {
+var BaseHttpTransport = class {
   buffer;
+  onErrorCallback;
   constructor(opts = {}) {
-    super();
+    this.onErrorCallback = opts.onError;
     this.buffer = new MessageBuffer({
       batchSize: opts.batchSize ?? DEFAULT_OPTIONS.batchSize,
       flushInterval: opts.flushInterval ?? DEFAULT_OPTIONS.flushInterval,
       maxRetries: opts.maxRetries ?? DEFAULT_OPTIONS.maxRetries,
       retryDelay: opts.retryDelay ?? DEFAULT_OPTIONS.retryDelay,
+      maxQueueSize: opts.maxQueueSize,
+      dropPolicy: opts.dropPolicy,
+      onDrop: opts.onDrop,
       onFlush: this.sendBatch.bind(this),
       onError: this.handleError.bind(this)
     });
@@ -140,8 +180,20 @@ var BaseHttpTransport = class extends EventEmitter {
     this.buffer.add(message);
     callback();
   }
-  close() {
-    return this.buffer.close();
+  /**
+   * Stop accepting new messages and flush what's buffered. `timeoutMs` caps
+   * how long the flush may take; after that the remaining queue is discarded
+   * so shutdown can complete. Default 5000ms.
+   */
+  close(timeoutMs) {
+    return this.buffer.close(timeoutMs);
+  }
+  /** Current buffered message count and total drops since creation. */
+  getMetrics() {
+    return {
+      queueSize: this.buffer.size,
+      droppedTotal: this.buffer.droppedTotal
+    };
   }
   transformMessage(info) {
     const { level, message, timestamp, context, ...meta } = info;
@@ -154,11 +206,21 @@ var BaseHttpTransport = class extends EventEmitter {
     };
   }
   handleError(error, messages) {
+    if (this.onErrorCallback) {
+      try {
+        this.onErrorCallback(error, messages);
+        return;
+      } catch (callbackError) {
+        console.error(
+          `[${this.constructor.name}] onError callback threw:`,
+          callbackError instanceof Error ? callbackError.message : callbackError
+        );
+      }
+    }
     console.error(
       `[${this.constructor.name}] Failed to send ${messages.length} messages:`,
       error.message
     );
-    this.emit("error", error);
   }
 };
 
@@ -183,16 +245,23 @@ var LEVEL_EMOJI = {
   debug: "\u26AA",
   silly: "\u26AB"
 };
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
 var DiscordTransport = class extends BaseHttpTransport {
   config;
+  requestTimeout;
   constructor(config) {
     super({
       batchSize: config.batchSize ?? 10,
       flushInterval: config.flushInterval ?? 2e3,
       maxRetries: config.maxRetries,
-      retryDelay: config.retryDelay
+      retryDelay: config.retryDelay,
+      maxQueueSize: config.maxQueueSize,
+      dropPolicy: config.dropPolicy,
+      onDrop: config.onDrop,
+      onError: config.onError
     });
     this.config = config;
+    this.requestTimeout = config.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
   }
   async sendBatch(messages) {
     if (this.config.format === "markdown") {
@@ -296,7 +365,8 @@ ${msg.message}`;
     const response = await fetch(this.config.webhookUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload)
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(this.requestTimeout)
     });
     if (!response.ok) {
       const text = await response.text();
@@ -323,18 +393,25 @@ var LEVEL_EMOJI2 = {
   debug: "\u26AA",
   silly: "\u26AB"
 };
+var DEFAULT_REQUEST_TIMEOUT_MS2 = 1e4;
 var TelegramTransport = class extends BaseHttpTransport {
   config;
   apiUrl;
+  requestTimeout;
   constructor(config) {
     super({
       batchSize: config.batchSize ?? 20,
       flushInterval: config.flushInterval ?? 1e3,
       maxRetries: config.maxRetries,
-      retryDelay: config.retryDelay
+      retryDelay: config.retryDelay,
+      maxQueueSize: config.maxQueueSize,
+      dropPolicy: config.dropPolicy,
+      onDrop: config.onDrop,
+      onError: config.onError
     });
     this.config = config;
     this.apiUrl = `https://api.telegram.org/bot${config.botToken}`;
+    this.requestTimeout = config.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS2;
   }
   async sendBatch(messages) {
     const text = this.formatBatchMessage(messages);
@@ -395,7 +472,8 @@ var TelegramTransport = class extends BaseHttpTransport {
     const response = await fetch(`${this.apiUrl}/sendMessage`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(this.requestTimeout)
     });
     if (!response.ok) {
       const result = await response.json();
@@ -464,7 +542,11 @@ var CloudWatchTransport = class extends BaseHttpTransport {
       batchSize: config.batchSize ?? 100,
       flushInterval: config.flushInterval ?? 1e3,
       maxRetries: config.maxRetries,
-      retryDelay: config.retryDelay
+      retryDelay: config.retryDelay,
+      maxQueueSize: config.maxQueueSize,
+      dropPolicy: config.dropPolicy,
+      onDrop: config.onDrop,
+      onError: config.onError
     });
     this.config = config;
     this.resolvedLogStreamName = resolveLogStreamName(config.logStreamName, configHostname);
@@ -516,7 +598,10 @@ var CloudWatchTransport = class extends BaseHttpTransport {
   async ensureInitialized() {
     if (this.initialized) return;
     if (!this.initPromise) {
-      this.initPromise = this.initialize();
+      this.initPromise = this.initialize().catch((err) => {
+        this.initPromise = null;
+        throw err;
+      });
     }
     await this.initPromise;
   }
@@ -592,15 +677,34 @@ function getLevelName(levelNum) {
   if (levelNum >= 20) return "debug";
   return "silly";
 }
-function shouldPassTransport(log, level, rules, store) {
+function shouldPassTransport(log, level, rules, state) {
   const logLevel = getLevelName(log.level);
+  const embeddedOverride = log.__or;
+  if (typeof embeddedOverride === "string") {
+    if (embeddedOverride === "off") return false;
+    const overrideLevel = embeddedOverride;
+    return LOG_LEVELS[logLevel] <= LOG_LEVELS[overrideLevel];
+  }
   const context = log.context;
-  const storeContext = store.getStore();
-  const matchingRule = rules?.find((rule) => matchesContext(storeContext, context, rule.match));
-  const effectiveLevel = matchingRule?.level ?? level ?? "silly";
+  if (rules && rules.length > 0) {
+    const storeContext = state.store.getStore();
+    const logMeta = {};
+    for (const [key, value] of Object.entries(log)) {
+      if (!RESERVED_LOG_FIELDS.has(key)) {
+        logMeta[key] = value;
+      }
+    }
+    const matchingRule = rules.find((rule) => matchesContext(storeContext, context, rule.match, logMeta));
+    if (matchingRule) {
+      if (matchingRule.level === "off") return false;
+      return LOG_LEVELS[logLevel] <= LOG_LEVELS[matchingRule.level];
+    }
+  }
+  const effectiveLevel = level ?? "silly";
   if (effectiveLevel === "off") return false;
   return LOG_LEVELS[logLevel] <= LOG_LEVELS[effectiveLevel];
 }
+var RESERVED_LOG_FIELDS = /* @__PURE__ */ new Set(["level", "time", "msg", "context", "__or"]);
 function formatLog(log, format, store) {
   const levelName = getLevelName(log.level);
   const timestamp = new Date(log.time).toISOString();
@@ -609,7 +713,7 @@ function formatLog(log, format, store) {
   const storeContext = store.getStore();
   const meta = {};
   for (const [key, value] of Object.entries(log)) {
-    if (!["level", "time", "msg", "context"].includes(key)) {
+    if (!RESERVED_LOG_FIELDS.has(key)) {
       meta[key] = value;
     }
   }
@@ -658,7 +762,7 @@ function formatLog(log, format, store) {
   return `[${timestamp}] ${levelName}: ${message}
 `;
 }
-function createFormattedFilterStream(format, level, rules, store, destination) {
+function createFormattedFilterStream(format, level, rules, state, destination) {
   return new Transform({
     transform(chunk, _encoding, callback) {
       const line = chunk.toString().trim();
@@ -671,24 +775,24 @@ function createFormattedFilterStream(format, level, rules, store, destination) {
         callback();
         return;
       }
-      if (!shouldPassTransport(log, level, rules, store)) {
+      if (!shouldPassTransport(log, level, rules, state)) {
         callback();
         return;
       }
-      const formatted = formatLog(log, format, store);
+      const formatted = formatLog(log, format, state.store);
       destination.write(formatted);
       callback();
     }
   });
 }
-function createStreams(config, store) {
+function createStreams(config, state) {
   const streams = [];
   const transports = [];
   const consoleStream = createFormattedFilterStream(
     config.console.format,
     config.console.level,
     config.console.rules,
-    store,
+    state,
     process.stdout
   );
   streams.push({
@@ -721,7 +825,7 @@ function createStreams(config, store) {
       fileConfig.format,
       fileConfig.level,
       fileConfig.rules,
-      store,
+      state,
       rotatingStream
     );
     streams.push({
@@ -732,7 +836,7 @@ function createStreams(config, store) {
   for (const discordConfig of toArray(config.discord)) {
     const transport = new DiscordTransport(discordConfig);
     transports.push(transport);
-    const discordStream = createHttpTransportStream(transport, discordConfig.level, discordConfig.rules, store);
+    const discordStream = createHttpTransportStream(transport, discordConfig.level, discordConfig.rules, state);
     streams.push({
       level: "trace",
       stream: discordStream
@@ -741,7 +845,7 @@ function createStreams(config, store) {
   for (const telegramConfig of toArray(config.telegram)) {
     const transport = new TelegramTransport(telegramConfig);
     transports.push(transport);
-    const telegramStream = createHttpTransportStream(transport, telegramConfig.level, telegramConfig.rules, store);
+    const telegramStream = createHttpTransportStream(transport, telegramConfig.level, telegramConfig.rules, state);
     streams.push({
       level: "trace",
       stream: telegramStream
@@ -750,12 +854,22 @@ function createStreams(config, store) {
   for (const cloudwatchConfig of toArray(config.cloudwatch)) {
     const transport = new CloudWatchTransport(cloudwatchConfig, config.hostname);
     transports.push(transport);
-    const cwStream = createHttpTransportStream(transport, cloudwatchConfig.level, cloudwatchConfig.rules, store);
+    const cwStream = createHttpTransportStream(transport, cloudwatchConfig.level, cloudwatchConfig.rules, state);
     streams.push({
       level: "trace",
       stream: cwStream
     });
   }
+  if (config.relay) {
+    const relayStream = pino.transport({
+      target: "@rawnodes/logger/relay",
+      options: config.relay
+    });
+    streams.push({
+      level: "trace",
+      stream: relayStream
+    });
+  }
   return {
     destination: pino.multistream(streams),
     transports
@@ -765,7 +879,7 @@ function toArray(value) {
   if (!value) return [];
   return Array.isArray(value) ? value : [value];
 }
-function createHttpTransportStream(transport, level, rules, store) {
+function createHttpTransportStream(transport, level, rules, state) {
   return new Writable({
     write(chunk, _encoding, callback) {
       const line = chunk.toString().trim();
@@ -778,15 +892,15 @@ function createHttpTransportStream(transport, level, rules, store) {
         callback();
         return;
       }
-      if (!shouldPassTransport(log, level, rules, store)) {
+      if (!shouldPassTransport(log, level, rules, state)) {
         callback();
         return;
       }
       const levelName = getLevelName(log.level);
-      const storeContext = store.getStore();
+      const storeContext = state.store.getStore();
       const meta = {};
       for (const [key, value] of Object.entries(log)) {
-        if (!["level", "time", "msg", "context"].includes(key)) {
+        if (!RESERVED_LOG_FIELDS.has(key)) {
           meta[key] = value;
         }
       }
@@ -835,45 +949,53 @@ function buildIndexes(overrides) {
   }
   return { contextIndex, complexRules };
 }
+function canonicalMatchKey(match) {
+  const keys = Object.keys(match).sort();
+  const sorted = {};
+  for (const key of keys) {
+    sorted[key] = match[key];
+  }
+  return JSON.stringify(sorted);
+}
 function createState(config, store) {
   const { defaultLevel, rules } = parseLevelConfig(config.level);
   const loggerStore = store ?? new LoggerStore();
   const levelOverrides = /* @__PURE__ */ new Map();
   for (const rule of rules) {
-    const key = JSON.stringify(rule.match);
+    const key = canonicalMatchKey(rule.match);
     levelOverrides.set(key, rule);
   }
   const { contextIndex, complexRules } = buildIndexes(levelOverrides);
-  const { destination, transports } = createStreams(config, loggerStore);
+  const state = {
+    pino: null,
+    store: loggerStore,
+    defaultLevel,
+    levelOverrides,
+    contextIndex,
+    complexRules,
+    callerConfig: void 0,
+    transports: []
+  };
+  const { destination, transports } = createStreams(config, state);
+  state.transports = transports;
   const options = {
     level: "trace",
     // Accept all, we filter in shouldLog()
     customLevels: CUSTOM_LEVELS,
     base: { hostname: config.hostname ?? hostname() }
   };
-  const pinoLogger = pino(options, destination);
-  let callerConfig;
+  state.pino = pino(options, destination);
   if (config.caller === true) {
-    callerConfig = {};
+    state.callerConfig = {};
   } else if (config.caller && typeof config.caller === "object") {
-    callerConfig = config.caller;
+    state.callerConfig = config.caller;
   }
-  return {
-    pino: pinoLogger,
-    store: loggerStore,
-    defaultLevel,
-    levelOverrides,
-    contextIndex,
-    complexRules,
-    callerConfig,
-    transports
-  };
+  return state;
 }
 function rebuildIndexes(state) {
   const { contextIndex, complexRules } = buildIndexes(state.levelOverrides);
   state.contextIndex = contextIndex;
-  state.complexRules.length = 0;
-  state.complexRules.push(...complexRules);
+  state.complexRules = complexRules;
 }
 function shouldLog(state, level, context) {
   const effectiveLevel = getEffectiveLevel(state, context);
@@ -893,10 +1015,24 @@ function getEffectiveLevel(state, loggerContext) {
   }
   return state.defaultLevel;
 }
-function matchesContext(storeContext, loggerContext, match) {
-  const combined = { ...storeContext, context: loggerContext };
+function matchesContext(storeContext, loggerContext, match, logMeta) {
+  const combined = { ...logMeta, ...storeContext, context: loggerContext };
   return Object.entries(match).every(([key, value]) => combined[key] === value);
 }
+function getGlobalOverrideLevel2(state, loggerContext, logMeta) {
+  if (loggerContext) {
+    const indexed = state.contextIndex.get(loggerContext);
+    if (indexed && !indexed.readonly) return indexed.level;
+  }
+  const storeContext = state.store.getStore();
+  for (const override of state.complexRules) {
+    if (override.readonly) continue;
+    if (matchesContext(storeContext, loggerContext, override.match, logMeta)) {
+      return override.level;
+    }
+  }
+  return void 0;
+}
 var LogLevelSchema = z.enum([
   "off",
   "error",
@@ -935,7 +1071,12 @@ var HttpTransportBaseConfigSchema = z.object({
   batchSize: z.number().int().positive().optional(),
   flushInterval: z.number().int().positive().optional(),
   maxRetries: z.number().int().nonnegative().optional(),
-  retryDelay: z.number().int().positive().optional()
+  retryDelay: z.number().int().positive().optional(),
+  onError: z.function().optional(),
+  onDrop: z.function().optional(),
+  maxQueueSize: z.number().int().positive().optional(),
+  dropPolicy: z.enum(["drop-oldest", "drop-newest"]).optional(),
+  requestTimeout: z.number().int().positive().optional()
 });
 var DiscordConfigSchema = z.object({
   level: LogLevelSchema.optional(),
@@ -944,6 +1085,11 @@ var DiscordConfigSchema = z.object({
   flushInterval: z.number().int().positive().optional(),
   maxRetries: z.number().int().nonnegative().optional(),
   retryDelay: z.number().int().positive().optional(),
+  onError: z.function().optional(),
+  onDrop: z.function().optional(),
+  maxQueueSize: z.number().int().positive().optional(),
+  dropPolicy: z.enum(["drop-oldest", "drop-newest"]).optional(),
+  requestTimeout: z.number().int().positive().optional(),
   webhookUrl: z.string().url("webhookUrl must be a valid URL"),
   format: z.enum(["embed", "markdown"]).optional(),
   username: z.string().optional(),
@@ -960,6 +1106,11 @@ var TelegramConfigSchema = z.object({
   flushInterval: z.number().int().positive().optional(),
   maxRetries: z.number().int().nonnegative().optional(),
   retryDelay: z.number().int().positive().optional(),
+  onError: z.function().optional(),
+  onDrop: z.function().optional(),
+  maxQueueSize: z.number().int().positive().optional(),
+  dropPolicy: z.enum(["drop-oldest", "drop-newest"]).optional(),
+  requestTimeout: z.number().int().positive().optional(),
   botToken: z.string().min(1, "botToken is required"),
   chatId: z.union([z.string(), z.number()]),
   parseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).optional(),
@@ -992,6 +1143,11 @@ var CloudWatchConfigSchema = z.object({
   flushInterval: z.number().int().positive().optional(),
   maxRetries: z.number().int().nonnegative().optional(),
   retryDelay: z.number().int().positive().optional(),
+  onError: z.function().optional(),
+  onDrop: z.function().optional(),
+  maxQueueSize: z.number().int().positive().optional(),
+  dropPolicy: z.enum(["drop-oldest", "drop-newest"]).optional(),
+  requestTimeout: z.number().int().positive().optional(),
   logGroupName: z.string().min(1, "logGroupName is required"),
   logStreamName: LogStreamNameSchema.optional(),
   region: z.string().min(1, "region is required"),
@@ -1000,6 +1156,14 @@ var CloudWatchConfigSchema = z.object({
   createLogGroup: z.boolean().optional(),
   createLogStream: z.boolean().optional()
 });
+var RelayConfigSchema = z.object({
+  apiUrl: z.string().url("apiUrl must be a valid URL"),
+  token: z.string().min(1, "token is required"),
+  pollInterval: z.number().int().positive().optional(),
+  bufferSize: z.number().int().positive().optional(),
+  reconnectDelay: z.number().int().positive().optional(),
+  maxReconnectDelay: z.number().int().positive().optional()
+});
 var LevelConfigObjectSchema = z.object({
   default: LogLevelSchema,
   rules: z.array(LevelRuleSchema).optional()
@@ -1023,6 +1187,7 @@ var LoggerConfigSchema = z.object({
   discord: z.union([DiscordConfigSchema, z.array(DiscordConfigSchema)]).optional(),
   telegram: z.union([TelegramConfigSchema, z.array(TelegramConfigSchema)]).optional(),
   cloudwatch: z.union([CloudWatchConfigSchema, z.array(CloudWatchConfigSchema)]).optional(),
+  relay: RelayConfigSchema.optional(),
   caller: z.union([z.boolean(), CallerConfigSchema]).optional(),
   hostname: z.string().optional(),
   autoShutdown: z.union([z.boolean(), AutoShutdownConfigSchema]).optional()
@@ -1270,7 +1435,10 @@ var Logger = class _Logger {
     this.state = state;
     this.context = context;
   }
-  profileTimers = /* @__PURE__ */ new Map();
+  // Lazy: `.for()` creates many child loggers (hot path), most never call
+  // `profile()`. Allocating a fresh Map per child wastes ~200 bytes each and
+  // caused OOM in benchmarks creating millions of children.
+  profileTimers;
   static create(config, store) {
     const validatedConfig = validateConfig(config);
     const state = createState(validatedConfig, store);
@@ -1290,12 +1458,12 @@ var Logger = class _Logger {
   }
   setLevelOverride(match, level) {
     assertLogLevel(level);
-    const key = JSON.stringify(match);
+    const key = canonicalMatchKey(match);
     this.state.levelOverrides.set(key, { match, level });
     rebuildIndexes(this.state);
   }
   removeLevelOverride(match) {
-    const key = JSON.stringify(match);
+    const key = canonicalMatchKey(match);
     const override = this.state.levelOverrides.get(key);
     if (override?.readonly) {
       return false;
@@ -1325,33 +1493,55 @@ var Logger = class _Logger {
   /**
    * Gracefully shutdown the logger, flushing all pending messages.
    * Should be called before process exit to ensure no logs are lost.
+   *
+   * `timeoutMs` is forwarded to each transport's `close()` as a per-transport
+   * cap; it prevents a dead transport from blocking the whole shutdown.
+   * Default: 5000ms. Pass `Infinity` for legacy unbounded behaviour.
    */
-  async shutdown() {
-    const closePromises = this.state.transports.map((transport) => transport.close());
+  async shutdown(timeoutMs = 5e3) {
+    const closePromises = this.state.transports.map((transport) => transport.close(timeoutMs));
     await Promise.all(closePromises);
   }
   // Profiling
   profile(id, meta) {
-    const existing = this.profileTimers.get(id);
+    const timers = this.profileTimers ??= /* @__PURE__ */ new Map();
+    const existing = timers.get(id);
     if (existing) {
       const duration = Date.now() - existing;
-      this.profileTimers.delete(id);
+      timers.delete(id);
       this.info(`${id} completed`, { ...meta, durationMs: duration });
     } else {
-      this.profileTimers.set(id, Date.now());
+      timers.set(id, Date.now());
     }
   }
   // Logging methods
+  /**
+   * Log an error. Supported shapes:
+   *   error(message: string)
+   *   error(message: string, meta)
+   *   error(error: Error | unknown)
+   *   error(error: Error | unknown, message: string)
+   *   error(error: Error | unknown, meta)
+   *   error(error: Error | unknown, message: string, meta)
+   *
+   * The first argument is treated as an error value whenever it is not a string.
+   * Non-Error values (plain objects, numbers, etc. — e.g. anything caught by
+   * TypeScript's `catch (err)` clause, which is typed as `unknown`) are passed
+   * through `serializeError` so they produce a sensible `errorMessage` and, when
+   * possible, a `stack` / HTTP diagnostic payload.
+   */
   error(errorOrMessage, messageOrMeta, meta) {
     if (!shouldLog(this.state, "error", this.context)) return;
-    if (errorOrMessage instanceof Error) {
-      if (typeof messageOrMeta === "string") {
-        this.log("error", messageOrMeta, meta, errorOrMessage);
-      } else {
-        this.log("error", errorOrMessage.message, messageOrMeta, errorOrMessage);
-      }
-    } else {
+    if (typeof errorOrMessage === "string") {
       this.log("error", errorOrMessage, messageOrMeta);
+      return;
+    }
+    const errorValue = errorOrMessage;
+    if (typeof messageOrMeta === "string") {
+      this.log("error", messageOrMeta, meta, errorValue);
+    } else {
+      const fallbackMessage = errorValue instanceof Error ? errorValue.message : serializeError(errorValue).errorMessage;
+      this.log("error", fallbackMessage, messageOrMeta, errorValue);
     }
   }
   warn(message, meta) {
@@ -1386,6 +1576,10 @@ var Logger = class _Logger {
     if (storeContext) {
       Object.assign(logMeta, storeContext);
     }
+    const overrideLevel = getGlobalOverrideLevel2(this.state, this.context, logMeta);
+    if (overrideLevel !== void 0) {
+      logMeta.__or = overrideLevel;
+    }
     if (this.state.callerConfig) {
       const callerInfo = getCallerInfo(this.state.callerConfig, callerOffset);
       if (callerInfo) {