@sockethub/logger 1.0.0-alpha.11 → 1.0.0-alpha.13

package/dist/index.d.ts

@@ -0,0 +1,129 @@
+import winston from "winston";
+export type Logger = winston.Logger;
+export interface LoggerOptions {
+    level?: string;
+    fileLevel?: string;
+    file?: string;
+}
+/**
+ * Initialize the logger system with global configuration.
+ *
+ * Called once at server bootstrap with config settings. All subsequent
+ * createLogger() calls will use these settings as defaults unless explicitly
+ * overridden.
+ *
+ * @param options - Global logger configuration
+ *
+ * @example
+ * ```typescript
+ * // In server bootstrap
+ * initLogger({
+ *   level: config.get("logging:level"),
+ *   fileLevel: config.get("logging:fileLevel"),
+ *   file: config.get("logging:file"),
+ * });
+ * ```
+ */
+export declare function initLogger(options: LoggerOptions): void;
+/**
+ * Set the logger context for this process.
+ *
+ * All subsequent createLogger() calls will prepend this context to their namespace.
+ * This is typically set once at process startup to identify the process (e.g., "sockethub"
+ * for the main server, or "sockethub:platform:irc:abc123" for a platform child process).
+ *
+ * @param context - The context string to prepend to all logger namespaces in this process
+ *
+ * @example
+ * ```typescript
+ * // In main server process
+ * setLoggerContext('sockethub');
+ * const log = createLogger('server:listener');
+ * // Output namespace: "sockethub:server:listener"
+ *
+ * // In platform child process
+ * setLoggerContext('sockethub:platform:irc:abc123');
+ * const log = createLogger('main');
+ * // Output namespace: "sockethub:platform:irc:abc123:main"
+ * ```
+ */
+export declare function setLoggerContext(context: string): void;
+/**
+ * Get the current logger context for this process.
+ *
+ * @returns The current logger context string, or empty string if not set
+ *
+ * @example
+ * ```typescript
+ * const context = getLoggerContext();
+ * if (context.includes(':platform:')) {
+ *   // We're in a platform child process
+ * }
+ * ```
+ */
+export declare function getLoggerContext(): string;
+/**
+ * Reset the logger context.
+ *
+ * Primarily used for testing to reset state between test cases.
+ *
+ * @example
+ * ```typescript
+ * afterEach(() => {
+ *   resetLoggerContext();
+ * });
+ * ```
+ */
+export declare function resetLoggerContext(): void;
+/**
+ * Creates a Winston logger instance with console and optional file transports.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Explicit options parameter
+ * 2. Global config (set via initLogger)
+ * 3. Environment variables (LOG_LEVEL, LOG_FILE_LEVEL, LOG_FILE)
+ * 4. Defaults (info for console, debug for file)
+ *
+ * Log levels: error, warn, info, debug
+ *
+ * NODE_ENV=production disables console timestamps (for systemd)
+ *
+ * @param namespace - Logger namespace (e.g., "sockethub:data-layer:queue:...")
+ * @param options - Optional logger configuration overrides
+ * @returns Winston logger instance
+ *
+ * @example
+ * ```typescript
+ * // Uses global config if initLogger() was called
+ * const log = createLogger("sockethub:data-layer:queue:irc-123");
+ *
+ * // Override for specific use case (e.g., early bootstrap logging)
+ * const earlyLog = createLogger("sockethub:bootstrap", { level: "info" });
+ * ```
+ */
+export declare function createLogger(namespace: string, options?: LoggerOptions): Logger;
+/**
+ * Get the namespace from a logger instance.
+ *
+ * Extracts the full namespace (including context) that was set when the logger was created.
+ * Useful for reusing the namespace in other systems like Redis connection names.
+ *
+ * @param logger - Logger instance created by createLogger()
+ * @returns The full namespace string, or empty string if not found
+ *
+ * @example
+ * ```typescript
+ * const log = createLogger('data-layer:queue');
+ * const namespace = getLoggerNamespace(log);
+ * // Returns: "sockethub:data-layer:queue" (if context is "sockethub")
+ *
+ * // Use for Redis connection name
+ * redisConfig.connectionName = namespace;
+ * ```
+ */
+export declare function getLoggerNamespace(logger: Logger): string;
+/**
+ * Reset logger state. Used primarily for testing.
+ * @internal
+ */
+export declare function resetLoggerForTesting(): void;

package/dist/index.js

@@ -4,15 +4,29 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
@@ -9881,6 +9895,36 @@ var globalConfig = null;
 var hasLoggedInit = false;
 var loggerContext = "";
 var loggerNamespaceStore = new WeakMap;
+function safeStringify(value) {
+  try {
+    const parents = [];
+    return JSON.stringify(value, function(_key, innerValue) {
+      if (innerValue instanceof Error) {
+        return {
+          name: innerValue.name,
+          message: innerValue.message,
+          stack: innerValue.stack
+        };
+      }
+      if (typeof innerValue === "bigint") {
+        return innerValue.toString();
+      }
+      if (typeof innerValue === "object" && innerValue !== null) {
+        const parent = this;
+        while (parents.length > 0 && parents[parents.length - 1] !== parent) {
+          parents.pop();
+        }
+        if (parents.includes(innerValue)) {
+          return "[Circular]";
+        }
+        parents.push(innerValue);
+      }
+      return innerValue;
+    });
+  } catch {
+    return '"[Unserializable]"';
+  }
+}
 function initLogger(options) {
   globalConfig = options;
   if (!hasLoggedInit) {
@@ -9913,11 +9957,11 @@ function createLogger(namespace, options = {}) {
   const isProduction = false;
   const consoleFormat = isProduction ? import_winston.default.format.combine(import_winston.default.format.colorize(), import_winston.default.format.printf(({ level, message, namespace: namespace2, ...meta }) => {
     const ns = namespace2 ? `${namespace2} ` : "";
-    const metaStr = Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
+    const metaStr = Object.keys(meta).length > 0 ? ` ${safeStringify(meta)}` : "";
     return `${level}: ${ns}${message}${metaStr}`;
   })) : import_winston.default.format.combine(import_winston.default.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), import_winston.default.format.colorize(), import_winston.default.format.printf(({ level, message, timestamp, namespace: namespace2, ...meta }) => {
     const ns = namespace2 ? `${namespace2} ` : "";
-    const metaStr = Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
+    const metaStr = Object.keys(meta).length > 0 ? ` ${safeStringify(meta)}` : "";
     return `${timestamp} ${level}: ${ns}${message}${metaStr}`;
   }));
   const transports = [
@@ -9960,4 +10004,4 @@ export {
   createLogger
 };
 
-//# debugId=D26653BFE0342E6864756E2164756E21
+//# debugId=E499E63CEE36E4A864756E2164756E21