@crimsonsunset/jsg-logger 1.7.15 → 1.8.0

package/config/config-manager.js

@@ -198,8 +198,6 @@ export class ConfigManager {
         
         // Handle environment-specific configurations 
         if (config.environments) {
-            // For now, just log that environment configs exist
-            // TODO: Implement environment-based config selection
             metaLog(`[JSG-LOGGER] Found environment configs for: ${Object.keys(config.environments).join(', ')}`);
         }
         
@@ -207,6 +205,11 @@ export class ConfigManager {
         if (config.components) {
             normalized.components = this._normalizeComponents(config.components);
         }
+
+        // Transports are live object instances — pass through as-is, no normalization
+        if (config.transports) {
+            normalized.transports = config.transports;
+        }
         
         return normalized;
     }
@@ -339,10 +342,11 @@ export class ConfigManager {
 
         for (const key in override) {
             if (override.hasOwnProperty(key)) {
-                // Special case: 'components' should be replaced, not merged
-                // This allows users to define their own components without getting defaults
                 if (key === 'components' && typeof override[key] === 'object') {
                     merged[key] = override[key];
+                } else if (key === 'transports') {
+                    // Transports are live object instances — always replace, never deep-merge
+                    merged[key] = override[key];
                 } else if (typeof override[key] === 'object' && !Array.isArray(override[key])) {
                     merged[key] = this.mergeConfigs(merged[key] || {}, override[key]);
                 } else {

package/index.d.ts

@@ -2,6 +2,52 @@
  * TypeScript definitions for @crimsonsunset/jsg-logger
  */
 
+// ---------------------------------------------------------------------------
+// Transport system
+// ---------------------------------------------------------------------------
+
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+
+/**
+ * Structured log entry passed to transports.
+ * Built automatically by the logger — consumers never create these directly.
+ */
+export interface LogEntry {
+  level: LogLevel;
+  levelNum: number;
+  message: string;
+  component: string;
+  data?: Record<string, unknown>;
+  timestamp: number;
+  /** true when levelNum >= 50 (error / fatal) */
+  isError: boolean;
+  /** Extracted Error instance from data (data itself, data.err, or data.error) */
+  error?: Error;
+}
+
+/**
+ * Thin interface that any external log service must implement.
+ * The library calls `send()` for every log that passes the transport's level gate.
+ *
+ * @example
+ * ```ts
+ * class DatadogTransport implements LogTransport {
+ *   level = 'warn' as const;
+ *   send(entry: LogEntry) { datadogClient.log(entry.message, entry.data); }
+ * }
+ * ```
+ */
+export interface LogTransport {
+  /** Minimum level this transport cares about. Logs below this are skipped. */
+  level?: LogLevel;
+  /** Called for each qualifying log entry. May return a Promise (fire-and-forget). */
+  send(entry: LogEntry): void | Promise<void>;
+}
+
+// ---------------------------------------------------------------------------
+// Logger core
+// ---------------------------------------------------------------------------
+
 export interface LoggerInstance {
   info: (message: string, data?: any) => void;
   debug: (message: string, data?: any) => void;
@@ -56,6 +102,8 @@ export interface JSGLoggerConfig {
   devtools?: {
     enabled?: boolean;
   };
+  /** External log service transports. Each receives qualifying LogEntry objects. */
+  transports?: LogTransport[];
   [key: string]: any;
 }
 

package/index.js

@@ -13,6 +13,7 @@ import {createCLIFormatter} from './formatters/cli-formatter.js';
 import {createServerFormatter, getServerConfig} from './formatters/server-formatter.js';
 import {LogStore} from './stores/log-store.js';
 import {metaLog, metaWarn, metaError} from './utils/meta-logger.js';
+import {buildLogEntry, dispatchToTransports} from './utils/transport-dispatcher.js';
 import packageJson from './package.json' with {type: 'json'};
 
 // Check default config for devtools at module load time
@@ -54,10 +55,11 @@ class JSGLogger {
     constructor() {
         this.loggers = {};
         this.logStore = new LogStore();
-        this.environment = null; // Will be set after config loads
+        this.environment = null;
         this.initialized = false;
-        this.components = {}; // Auto-discovery getters
-        this.componentSubscribers = []; // Subscribers for component change events
+        this.components = {};
+        this.componentSubscribers = [];
+        this.transports = [];
     }
 
     /**
@@ -192,6 +194,9 @@ class JSGLogger {
             // NOW determine environment (after config is loaded and forceEnvironment is applied)
             this.environment = getEnvironment();
 
+            // Pick up transports from config (live objects — not deep-merged)
+            this.transports = configManager.config.transports ?? [];
+
             // Create loggers for all available components
             const components = configManager.getAvailableComponents();
 
@@ -199,11 +204,6 @@ class JSGLogger {
                 this.loggers[componentName] = this.createLogger(componentName);
             });
 
-            // Create legacy compatibility aliases
-            // Removed: camelCase aliases no longer added to this.loggers
-            // Use logger.components.camelCase() or logger.getComponent('kebab-case') instead
-            // this.createAliases();
-
             // Add utility methods
             this.addUtilityMethods();
 
@@ -303,6 +303,9 @@ class JSGLogger {
             // NOW determine environment (after config is loaded and forceEnvironment is applied)
             this.environment = getEnvironment();
 
+            // Pick up transports from config (live objects — not deep-merged)
+            this.transports = configManager.config.transports ?? [];
+
             // Clear existing loggers for clean reinitialization
             this.loggers = {};
             this.components = {};
@@ -311,13 +314,9 @@ class JSGLogger {
             const components = configManager.getAvailableComponents();
 
             components.forEach(componentName => {
-                // Use original createLogger to bypass utility method caching
                 const createFn = this._createLoggerOriginal || this.createLogger.bind(this);
                 this.loggers[componentName] = createFn(componentName);
             });
-
-            // Create legacy compatibility aliases
-            // Removed: camelCase aliases no longer added to this.loggers
             // Use logger.components.camelCase() or logger.getComponent('kebab-case') instead
             // this.createAliases();
 
@@ -432,28 +431,37 @@ class JSGLogger {
      */
     _wrapPinoLogger(pinoLogger) {
         const levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+        const levelNums = {trace: 10, debug: 20, info: 30, warn: 40, error: 50, fatal: 60};
         const wrapped = {};
+        const self = this;
 
         levels.forEach(level => {
             wrapped[level] = (first, ...args) => {
+                let message = '';
+                let data;
+
                 // Handle different argument patterns
                 if (typeof first === 'string') {
-                    // Pattern: logger.info('message', {context})
-                    const message = first;
+                    message = first;
                     if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null) {
-                        // Has context object
+                        data = args[0];
                         pinoLogger[level](args[0], message);
                     } else {
-                        // Just message
                         pinoLogger[level](message);
                     }
                 } else if (typeof first === 'object' && first !== null) {
-                    // Pattern: logger.info({context}, 'message') - already pino format
+                    data = first;
+                    message = (args.length > 0 && typeof args[0] === 'string') ? args[0] : '';
                     pinoLogger[level](first, ...args);
                 } else {
-                    // Fallback: just pass through
                     pinoLogger[level](first, ...args);
                 }
+
+                // Dispatch to transports
+                if (self.transports && self.transports.length > 0) {
+                    const entry = buildLogEntry(level, levelNums[level], pinoLogger._componentName, message, data);
+                    dispatchToTransports(entry, self.transports);
+                }
             };
         });
 
@@ -739,6 +747,7 @@ class JSGLogger {
         const formatter = createBrowserFormatter(componentName, this.logStore);
         const levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
         const levelMap = {trace: 10, debug: 20, info: 30, warn: 40, error: 50, fatal: 60};
+        const self = this;
 
         const logger = {};
 
@@ -751,7 +760,6 @@ class JSGLogger {
                 const minLevel = levelMap[effectiveLevel] || 30;
                 if (logLevel < minLevel) return;
 
-                // Create log data object
                 let logData = {
                     level: logLevel,
                     time: Date.now(),
@@ -759,24 +767,35 @@ class JSGLogger {
                     v: 1
                 };
 
+                let message = '';
+                let data;
+
                 // Handle different argument patterns
                 if (typeof first === 'string') {
+                    message = first;
                     logData.msg = first;
-                    // Add additional args as context
                     if (args.length === 1 && typeof args[0] === 'object') {
+                        data = args[0];
                         Object.assign(logData, args[0]);
                     } else if (args.length > 0) {
                         logData.args = args;
                     }
                 } else if (typeof first === 'object') {
+                    data = first;
                     Object.assign(logData, first);
                     if (args.length > 0 && typeof args[0] === 'string') {
+                        message = args[0];
                         logData.msg = args[0];
                     }
                 }
 
-                // Use our beautiful formatter
                 formatter.write(JSON.stringify(logData));
+
+                // Dispatch to transports
+                if (self.transports && self.transports.length > 0) {
+                    const entry = buildLogEntry(level, logLevel, componentName, message, data);
+                    dispatchToTransports(entry, self.transports);
+                }
             };
         });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crimsonsunset/jsg-logger",
-  "version": "1.7.15",
+  "version": "1.8.0",
   "type": "module",
   "description": "Multi-environment logger with smart detection, file-level overrides, and beautiful console formatting. Test it live: https://logger.joesangiorgio.com/",
   "main": "index.js",

package/utils/redaction.js

@@ -49,3 +49,6 @@ export function redactValue(value, redactConfig) {
   return value;
 }
 
+
+
+

package/utils/transport-dispatcher.js

@@ -0,0 +1,86 @@
+/**
+ * Transport Dispatcher for JSG Logger
+ * Builds log entries and dispatches them to registered transports.
+ * Transports are consumer-provided objects implementing the LogTransport interface.
+ */
+
+import { metaError } from './meta-logger.js';
+
+const LEVEL_NAMES = {
+    10: 'trace',
+    20: 'debug',
+    30: 'info',
+    40: 'warn',
+    50: 'error',
+    60: 'fatal',
+};
+
+const LEVEL_NUMS = {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60,
+};
+
+/**
+ * Extract an Error instance from log data if one is present.
+ * Checks the value itself, then common keys: `err`, `error`.
+ * @param {*} data - The data argument passed to the log method
+ * @returns {Error|undefined}
+ */
+function extractError(data) {
+    if (data instanceof Error) return data;
+    if (data && typeof data === 'object') {
+        if (data.err instanceof Error) return data.err;
+        if (data.error instanceof Error) return data.error;
+    }
+    return undefined;
+}
+
+/**
+ * Build a structured LogEntry from raw log call arguments.
+ * @param {string} level - Level name ('info', 'warn', 'error', etc.)
+ * @param {number} levelNum - Numeric level (10–60)
+ * @param {string} component - Component name
+ * @param {string} message - Log message
+ * @param {Record<string, unknown>} [data] - Optional context/data object
+ * @returns {Object} LogEntry
+ */
+export function buildLogEntry(level, levelNum, component, message, data) {
+    return {
+        level,
+        levelNum,
+        message: message ?? '',
+        component,
+        data,
+        timestamp: Date.now(),
+        isError: levelNum >= 50,
+        error: extractError(data),
+    };
+}
+
+/**
+ * Dispatch a LogEntry to all registered transports.
+ * Each transport is called independently — a failing transport never
+ * blocks or crashes the others (or the app).
+ * @param {Object} entry - LogEntry object
+ * @param {Array} transports - Array of LogTransport instances
+ */
+export function dispatchToTransports(entry, transports) {
+    if (!transports || transports.length === 0) return;
+
+    const entryLevelNum = entry.levelNum;
+
+    for (const transport of transports) {
+        try {
+            const minLevel = transport.level ? (LEVEL_NUMS[transport.level] ?? 0) : 0;
+            if (entryLevelNum < minLevel) continue;
+
+            transport.send(entry);
+        } catch (err) {
+            metaError('[JSG-LOGGER] Transport dispatch error:', err);
+        }
+    }
+}