@hamak/logging-impl 0.4.1

package/dist/es2015/core/log-manager.js

@@ -0,0 +1,255 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ContextLogger } from './context-logger.js';
+import { EventEmitter } from '../utils/event-emitter.js';
+/**
+ * Central log manager implementation
+ *
+ * Manages transports, creates loggers, and dispatches log entries.
+ */
+export class LogManager {
+    constructor(config = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        this.transports = new Map();
+        this.transportConfigs = new Map();
+        this.loggers = new Map();
+        this.buffer = [];
+        this.eventEmitter = new EventEmitter();
+        this.config = {
+            globalLevel: (_a = config.globalLevel) !== null && _a !== void 0 ? _a : 2, // LogLevel.INFO
+            bufferSize: (_b = config.bufferSize) !== null && _b !== void 0 ? _b : 1000,
+            flushInterval: (_c = config.flushInterval) !== null && _c !== void 0 ? _c : 5000,
+            defaultTransports: (_d = config.defaultTransports) !== null && _d !== void 0 ? _d : [],
+            pluginLevels: (_e = config.pluginLevels) !== null && _e !== void 0 ? _e : {},
+            moduleLevels: (_f = config.moduleLevels) !== null && _f !== void 0 ? _f : {},
+        };
+        if (this.config.flushInterval > 0) {
+            this.startFlushTimer();
+        }
+    }
+    registerTransport(transport, config) {
+        this.transports.set(transport.id, transport);
+        if (config) {
+            this.transportConfigs.set(transport.id, Object.assign({ enabled: true }, config));
+        }
+        else {
+            this.transportConfigs.set(transport.id, {
+                id: transport.id,
+                enabled: true,
+            });
+        }
+    }
+    unregisterTransport(id) {
+        const transport = this.transports.get(id);
+        if (transport && transport.close) {
+            transport.close().catch((error) => {
+                this.handleTransportError(transport, error);
+            });
+        }
+        this.transports.delete(id);
+        this.transportConfigs.delete(id);
+    }
+    getTransport(id) {
+        return this.transports.get(id);
+    }
+    listTransports() {
+        return Array.from(this.transports.values());
+    }
+    createLogger(context) {
+        const level = this.resolveLevel(context);
+        return new ContextLogger(this, context, level);
+    }
+    getLogger(context) {
+        const key = this.createCacheKey(context);
+        let logger = this.loggers.get(key);
+        if (!logger) {
+            logger = this.createLogger(context);
+            this.loggers.set(key, logger);
+        }
+        return logger;
+    }
+    setGlobalLevel(level) {
+        this.config.globalLevel = level;
+    }
+    setPluginLevel(plugin, level) {
+        this.config.pluginLevels[plugin] = level;
+    }
+    setModuleLevel(module, level) {
+        this.config.moduleLevels[module] = level;
+    }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entries = this.buffer.splice(0);
+            if (entries.length === 0) {
+                return;
+            }
+            yield Promise.all(entries.map(entry => this.dispatchToTransports(entry)));
+            yield Promise.all(Array.from(this.transports.values())
+                .filter(t => t.flush)
+                .map(t => {
+                try {
+                    return t.flush();
+                }
+                catch (error) {
+                    this.handleTransportError(t, error);
+                    return Promise.resolve();
+                }
+            }));
+            this.eventEmitter.emit('flush', entries.length);
+        });
+    }
+    clearBuffer() {
+        this.buffer = [];
+    }
+    on(event, handler) {
+        this.eventEmitter.on(event, handler);
+    }
+    off(event, handler) {
+        this.eventEmitter.off(event, handler);
+    }
+    dispatch(entry) {
+        this.buffer.push(entry);
+        this.eventEmitter.emit('log', entry);
+        // Immediate dispatch for high-priority logs
+        if (entry.level >= 4) { // LogLevel.ERROR
+            this.dispatchToTransports(entry).catch(error => {
+                console.error('[LogManager] Error dispatching log entry:', error);
+            });
+        }
+        // Flush if buffer is full
+        if (this.buffer.length >= this.config.bufferSize) {
+            this.flush().catch(error => {
+                console.error('[LogManager] Error flushing buffer:', error);
+            });
+        }
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.flushTimer) {
+                clearInterval(this.flushTimer);
+                this.flushTimer = undefined;
+            }
+            yield this.flush();
+            yield Promise.all(Array.from(this.transports.values())
+                .filter(t => t.close)
+                .map(t => t.close()));
+            this.transports.clear();
+            this.transportConfigs.clear();
+            this.loggers.clear();
+            this.eventEmitter.clear();
+        });
+    }
+    dispatchToTransports(entry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            for (const [id, transport] of this.transports) {
+                const config = this.transportConfigs.get(id);
+                if (!this.shouldDispatch(entry, config, transport)) {
+                    continue;
+                }
+                try {
+                    const result = transport.log(entry);
+                    if (result instanceof Promise) {
+                        promises.push(result.catch(error => {
+                            this.handleTransportError(transport, error);
+                        }));
+                    }
+                }
+                catch (error) {
+                    this.handleTransportError(transport, error);
+                }
+            }
+            yield Promise.all(promises);
+        });
+    }
+    shouldDispatch(entry, config, transport) {
+        var _a;
+        if (config && config.enabled === false) {
+            return false;
+        }
+        if ((config === null || config === void 0 ? void 0 : config.minLevel) !== undefined && entry.level < config.minLevel) {
+            return false;
+        }
+        if ((config === null || config === void 0 ? void 0 : config.maxLevel) !== undefined && entry.level > config.maxLevel) {
+            return false;
+        }
+        if ((config === null || config === void 0 ? void 0 : config.plugins) && config.plugins.length > 0) {
+            if (!entry.context.plugin || !config.plugins.includes(entry.context.plugin)) {
+                return false;
+            }
+        }
+        if ((config === null || config === void 0 ? void 0 : config.modules) && config.modules.length > 0) {
+            if (!entry.context.module || !config.modules.includes(entry.context.module)) {
+                return false;
+            }
+        }
+        if ((config === null || config === void 0 ? void 0 : config.tags) && config.tags.length > 0) {
+            if (!((_a = entry.metadata) === null || _a === void 0 ? void 0 : _a.tags) || !config.tags.some(tag => entry.metadata.tags.includes(tag))) {
+                return false;
+            }
+        }
+        if ((config === null || config === void 0 ? void 0 : config.filter) && !config.filter(entry)) {
+            return false;
+        }
+        if ((transport === null || transport === void 0 ? void 0 : transport.shouldLog) && !transport.shouldLog(entry)) {
+            return false;
+        }
+        return true;
+    }
+    resolveLevel(context) {
+        if (context === null || context === void 0 ? void 0 : context.plugin) {
+            const pluginLevel = this.config.pluginLevels[context.plugin];
+            if (pluginLevel !== undefined) {
+                return pluginLevel;
+            }
+        }
+        if (context === null || context === void 0 ? void 0 : context.module) {
+            const moduleLevel = this.config.moduleLevels[context.module];
+            if (moduleLevel !== undefined) {
+                return moduleLevel;
+            }
+        }
+        return this.config.globalLevel;
+    }
+    createCacheKey(context) {
+        if (!context) {
+            return '__default__';
+        }
+        return JSON.stringify({
+            plugin: context.plugin,
+            module: context.module,
+            component: context.component,
+        });
+    }
+    startFlushTimer() {
+        this.flushTimer = setInterval(() => {
+            this.flush().catch(error => {
+                console.error('[LogManager] Error in flush timer:', error);
+            });
+        }, this.config.flushInterval);
+    }
+    handleTransportError(transport, error) {
+        this.eventEmitter.emit('error', { transport: transport.id, error });
+        if (transport.onError) {
+            try {
+                transport.onError(error);
+            }
+            catch (handlerError) {
+                console.error('[LogManager] Error in transport error handler:', handlerError);
+            }
+        }
+        else {
+            console.error(`[LogManager] Transport '${transport.id}' error:`, error);
+        }
+    }
+}

package/dist/es2015/formatters/dev-formatter.js

@@ -0,0 +1,152 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/**
+ * Development formatter with colors and emojis
+ *
+ * Provides rich, human-readable console output for development.
+ */
+export class DevFormatter {
+    constructor(config = {}) {
+        var _a, _b, _c, _d;
+        this.config = config;
+        this.config = {
+            colors: (_a = config.colors) !== null && _a !== void 0 ? _a : true,
+            emojis: (_b = config.emojis) !== null && _b !== void 0 ? _b : true,
+            timestamps: (_c = config.timestamps) !== null && _c !== void 0 ? _c : true,
+            showContext: (_d = config.showContext) !== null && _d !== void 0 ? _d : true,
+        };
+    }
+    format(entry) {
+        const parts = [];
+        // Timestamp
+        if (this.config.timestamps) {
+            parts.push(this.formatTimestamp(entry.timestamp));
+        }
+        // Level with emoji and color
+        parts.push(this.formatLevel(entry.level));
+        // Context (plugin/module/component)
+        if (this.config.showContext) {
+            const context = this.formatContext(entry.context);
+            if (context) {
+                parts.push(context);
+            }
+        }
+        // Message
+        parts.push(entry.message);
+        // Metadata
+        const metadata = this.formatMetadata(entry.metadata);
+        if (metadata) {
+            parts.push(metadata);
+        }
+        return parts.join(' ');
+    }
+    formatBatch(entries) {
+        return entries.map(e => this.format(e)).join('\n');
+    }
+    formatTimestamp(timestamp) {
+        const date = new Date(timestamp);
+        const time = date.toISOString().split('T')[1].split('.')[0];
+        return this.config.colors ? `\x1b[90m${time}\x1b[0m` : time;
+    }
+    formatLevel(level) {
+        const emoji = this.config.emojis ? this.getLevelEmoji(level) : '';
+        const label = this.getLevelLabel(level);
+        const colored = this.config.colors ? this.colorize(label, level) : label;
+        return emoji ? `${emoji} ${colored}` : colored;
+    }
+    getLevelEmoji(level) {
+        switch (level) {
+            case 0: return '🔍'; // TRACE
+            case 1: return '🐛'; // DEBUG
+            case 2: return 'ℹ️ '; // INFO
+            case 3: return '⚠️ '; // WARN
+            case 4: return '❌'; // ERROR
+            case 5: return '💀'; // FATAL
+            default: return '';
+        }
+    }
+    getLevelLabel(level) {
+        switch (level) {
+            case 0: return 'TRACE';
+            case 1: return 'DEBUG';
+            case 2: return 'INFO ';
+            case 3: return 'WARN ';
+            case 4: return 'ERROR';
+            case 5: return 'FATAL';
+            default: return 'UNKNW';
+        }
+    }
+    colorize(text, level) {
+        const colors = {
+            0: '\x1b[90m', // TRACE - Gray
+            1: '\x1b[36m', // DEBUG - Cyan
+            2: '\x1b[32m', // INFO - Green
+            3: '\x1b[33m', // WARN - Yellow
+            4: '\x1b[31m', // ERROR - Red
+            5: '\x1b[35m', // FATAL - Magenta
+        };
+        const color = colors[level] || '\x1b[0m';
+        const reset = '\x1b[0m';
+        return `${color}${text}${reset}`;
+    }
+    formatContext(context) {
+        const parts = [];
+        if (context.plugin) {
+            parts.push(this.config.colors
+                ? `\x1b[35m[${context.plugin}]\x1b[0m`
+                : `[${context.plugin}]`);
+        }
+        if (context.module) {
+            parts.push(this.config.colors
+                ? `\x1b[34m{${context.module}}\x1b[0m`
+                : `{${context.module}}`);
+        }
+        if (context.component) {
+            parts.push(this.config.colors
+                ? `\x1b[36m<${context.component}>\x1b[0m`
+                : `<${context.component}>`);
+        }
+        if (context.operation) {
+            parts.push(this.config.colors
+                ? `\x1b[90m(${context.operation})\x1b[0m`
+                : `(${context.operation})`);
+        }
+        return parts.join(' ');
+    }
+    formatMetadata(metadata) {
+        if (!metadata || Object.keys(metadata).length === 0) {
+            return '';
+        }
+        const { error, stack, tags, duration } = metadata, rest = __rest(metadata, ["error", "stack", "tags", "duration"]);
+        const parts = [];
+        // Duration
+        if (duration !== undefined) {
+            const color = this.config.colors ? '\x1b[33m' : '';
+            const reset = this.config.colors ? '\x1b[0m' : '';
+            parts.push(`${color}⏱  ${duration}ms${reset}`);
+        }
+        // Tags
+        if (tags && tags.length > 0) {
+            const tagString = tags.map(t => `#${t}`).join(' ');
+            const color = this.config.colors ? '\x1b[90m' : '';
+            const reset = this.config.colors ? '\x1b[0m' : '';
+            parts.push(`${color}${tagString}${reset}`);
+        }
+        // Other metadata
+        if (Object.keys(rest).length > 0) {
+            const color = this.config.colors ? '\x1b[90m' : '';
+            const reset = this.config.colors ? '\x1b[0m' : '';
+            parts.push(`${color}${JSON.stringify(rest)}${reset}`);
+        }
+        return parts.length > 0 ? parts.join(' ') : '';
+    }
+}

package/dist/es2015/formatters/index.js

@@ -0,0 +1,2 @@
+export * from './dev-formatter.js';
+export * from './json-formatter.js';

package/dist/es2015/formatters/json-formatter.js

@@ -0,0 +1,69 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/**
+ * JSON formatter for structured logging
+ *
+ * Outputs logs as JSON for easy parsing by log aggregation tools.
+ */
+export class JsonFormatter {
+    constructor(config = {}) {
+        var _a, _b;
+        this.config = config;
+        this.config = Object.assign({ pretty: (_a = config.pretty) !== null && _a !== void 0 ? _a : false, includeStack: (_b = config.includeStack) !== null && _b !== void 0 ? _b : true }, config);
+    }
+    format(entry) {
+        const logObject = this.toObject(entry);
+        return this.config.pretty
+            ? JSON.stringify(logObject, null, 2)
+            : JSON.stringify(logObject);
+    }
+    formatBatch(entries) {
+        const logObjects = entries.map(e => this.toObject(e));
+        return this.config.pretty
+            ? JSON.stringify(logObjects, null, 2)
+            : JSON.stringify(logObjects);
+    }
+    toObject(entry) {
+        const obj = {
+            timestamp: entry.timestamp,
+            level: this.getLevelName(entry.level),
+            message: entry.message,
+        };
+        // Add context
+        if (entry.context && Object.keys(entry.context).length > 0) {
+            obj.context = entry.context;
+        }
+        // Add metadata
+        if (entry.metadata) {
+            const _a = entry.metadata, { error, stack } = _a, rest = __rest(_a, ["error", "stack"]);
+            if (Object.keys(rest).length > 0) {
+                obj.metadata = rest;
+            }
+            // Handle error separately
+            if (error) {
+                obj.error = Object.assign({ name: error.name, message: error.message }, (this.config.includeStack && stack ? { stack } : {}));
+            }
+        }
+        return obj;
+    }
+    getLevelName(level) {
+        switch (level) {
+            case 0: return 'TRACE';
+            case 1: return 'DEBUG';
+            case 2: return 'INFO';
+            case 3: return 'WARN';
+            case 4: return 'ERROR';
+            case 5: return 'FATAL';
+            default: return 'UNKNOWN';
+        }
+    }
+}

package/dist/es2015/index.js

@@ -0,0 +1,19 @@
+/**
+ * @hamak/logging-impl
+ *
+ * Core implementation of the pluggable logging system.
+ * Provides LogManager, ContextLogger, transports, and formatters.
+ *
+ * @packageDocumentation
+ */
+// Export core implementations
+export * from './core/index.js';
+// Export transports
+export * from './transports/index.js';
+// Export formatters
+export * from './formatters/index.js';
+// Export plugin factory
+export * from './plugin/index.js';
+// Export utilities
+export * from './utils/index.js';
+export { LOG_MANAGER_TOKEN, LOGGER_TOKEN, LOG_CONFIG_TOKEN, } from '@hamak/logging-api';

package/dist/es2015/plugin/index.js

@@ -0,0 +1 @@
+export * from './logging-plugin-factory.js';

package/dist/es2015/plugin/logging-plugin-factory.js

@@ -0,0 +1,118 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LOG_MANAGER_TOKEN, LOGGER_TOKEN, LOG_CONFIG_TOKEN } from '@hamak/logging-api';
+import { LogManager } from '../core/log-manager.js';
+import { ConsoleTransport } from '../transports/console-transport.js';
+import { DevFormatter } from '../formatters/dev-formatter.js';
+import { JsonFormatter } from '../formatters/json-formatter.js';
+import { ConsoleInterceptor } from '../utils/console-interceptor.js';
+/**
+ * Create a logging plugin for the microkernel
+ *
+ * @example
+ * ```typescript
+ * import { createLoggingPlugin } from '@hamak/logging-impl';
+ *
+ * const loggingPlugin = createLoggingPlugin({
+ *   globalLevel: LogLevel.DEBUG,
+ *   pluginLevels: {
+ *     'my-plugin': LogLevel.TRACE
+ *   }
+ * });
+ *
+ * const host = createHost({
+ *   plugins: [loggingPlugin, myPlugin]
+ * });
+ * ```
+ */
+export function createLoggingPlugin(config = {}) {
+    let logManager;
+    let rootLogger;
+    let consoleInterceptor;
+    // Determine environment
+    const isDevelopment = typeof process !== 'undefined'
+        ? process.env.NODE_ENV === 'development'
+        : true;
+    const defaultConfig = Object.assign({ globalLevel: isDevelopment ? 1 : 2, bufferSize: 1000, flushInterval: 5000, devFormatter: isDevelopment, interceptConsole: true, pluginLevels: {}, moduleLevels: {} }, config);
+    return {
+        initialize(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Create log manager
+                logManager = new LogManager(defaultConfig);
+                rootLogger = logManager.createLogger({ plugin: 'logging', module: 'plugin' });
+                // Register console transport
+                const formatter = defaultConfig.devFormatter
+                    ? new DevFormatter({
+                        colors: true,
+                        emojis: true,
+                        timestamps: true,
+                        showContext: true,
+                    })
+                    : new JsonFormatter({ pretty: isDevelopment });
+                logManager.registerTransport(new ConsoleTransport(formatter), {
+                    id: 'console',
+                    enabled: true,
+                    minLevel: defaultConfig.globalLevel,
+                });
+                // Register services via DI
+                ctx.provide({ provide: LOG_MANAGER_TOKEN, useValue: logManager });
+                ctx.provide({ provide: LOG_CONFIG_TOKEN, useValue: defaultConfig });
+                // Provide logger factory
+                ctx.provide({
+                    provide: LOGGER_TOKEN,
+                    useFactory: (pluginName) => {
+                        return logManager.createLogger({ plugin: pluginName });
+                    },
+                    deps: [],
+                });
+                rootLogger.info('Logging plugin initialized', {
+                    globalLevel: defaultConfig.globalLevel,
+                    formatter: defaultConfig.devFormatter ? 'dev' : 'json',
+                    tags: ['initialization'],
+                });
+            });
+        },
+        activate(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Bridge microkernel events to logging
+                ctx.hooks.on('plugin:error', ({ plugin, error }) => {
+                    const logger = logManager.createLogger({ plugin });
+                    logger.error('Plugin error', error);
+                });
+                ctx.hooks.on('host:activated', () => {
+                    rootLogger.info('Microkernel host activated', { tags: ['lifecycle'] });
+                });
+                // Intercept console methods if enabled
+                if (defaultConfig.interceptConsole) {
+                    consoleInterceptor = new ConsoleInterceptor(logManager);
+                    consoleInterceptor.intercept();
+                    rootLogger.debug('Console interception enabled', { tags: ['console'] });
+                }
+                // Emit logging ready event
+                ctx.hooks.emit('logging:ready', { logManager });
+                rootLogger.info('Logging plugin activated', {
+                    tags: ['lifecycle'],
+                    interceptConsole: defaultConfig.interceptConsole,
+                });
+            });
+        },
+        deactivate() {
+            return __awaiter(this, void 0, void 0, function* () {
+                rootLogger.info('Logging plugin deactivating', { tags: ['lifecycle'] });
+                // Restore original console methods
+                if (consoleInterceptor) {
+                    consoleInterceptor.restore();
+                    rootLogger.debug('Console interception disabled', { tags: ['console'] });
+                }
+                yield logManager.destroy();
+            });
+        },
+    };
+}

package/dist/es2015/transports/console-transport.js

@@ -0,0 +1,41 @@
+/**
+ * Console transport
+ *
+ * Outputs logs to the browser console or Node.js console.
+ * Supports formatting via pluggable formatters.
+ */
+export class ConsoleTransport {
+    constructor(formatter) {
+        this.formatter = formatter;
+        this.id = 'console';
+        this.name = 'Console Transport';
+    }
+    log(entry) {
+        var _a;
+        const formatted = this.formatter.format(entry);
+        switch (entry.level) {
+            case 0: // TRACE
+            case 1: // DEBUG
+                console.debug(formatted);
+                break;
+            case 2: // INFO
+                console.info(formatted);
+                break;
+            case 3: // WARN
+                console.warn(formatted);
+                break;
+            case 4: // ERROR
+            case 5: // FATAL
+                console.error(formatted);
+                if ((_a = entry.metadata) === null || _a === void 0 ? void 0 : _a.error) {
+                    console.error(entry.metadata.error);
+                }
+                break;
+            default:
+                console.log(formatted);
+        }
+    }
+    onError(error) {
+        console.error('[ConsoleTransport] Error:', error);
+    }
+}

package/dist/es2015/transports/index.js

@@ -0,0 +1 @@
+export * from './console-transport.js';