@hamak/logging-impl 0.4.1

package/dist/core/context-logger.d.ts

@@ -0,0 +1,26 @@
+import type { ILogger, ILogManager, LogLevel, LogContext, LogMetadata } from '@hamak/logging-api';
+/**
+ * Logger implementation with context awareness
+ *
+ * Tracks plugin/module/component hierarchy and supports child loggers.
+ */
+export declare class ContextLogger implements ILogger {
+    private manager;
+    private context;
+    private minLevel;
+    private timers;
+    constructor(manager: ILogManager, context: LogContext | undefined, minLevel: LogLevel);
+    trace(message: string, meta?: LogMetadata): void;
+    debug(message: string, meta?: LogMetadata): void;
+    info(message: string, meta?: LogMetadata): void;
+    warn(message: string, meta?: LogMetadata): void;
+    error(message: string, error?: Error, meta?: LogMetadata): void;
+    fatal(message: string, error?: Error, meta?: LogMetadata): void;
+    private log;
+    child(context: LogContext): ILogger;
+    scoped(context: LogContext, fn: (logger: ILogger) => void): void;
+    isLevelEnabled(level: LogLevel): boolean;
+    time(label: string): void;
+    timeEnd(label: string): void;
+}
+//# sourceMappingURL=context-logger.d.ts.map

package/dist/core/context-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-logger.d.ts","sourceRoot":"","sources":["../../src/core/context-logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAElG;;;;GAIG;AACH,qBAAa,aAAc,YAAW,OAAO;IAIzC,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ;IALlB,OAAO,CAAC,MAAM,CAA6B;gBAGjC,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,UAAU,YAAK,EACxB,QAAQ,EAAE,QAAQ;IAG5B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI;IAKhD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI;IAKhD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI;IAK/C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI;IAK/C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI;IAS/D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI;IAS/D,OAAO,CAAC,GAAG;IAYX,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO;IAQnC,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI;IAKhE,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAIxC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIzB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAQ7B"}

package/dist/core/context-logger.js

@@ -0,0 +1,82 @@
+/**
+ * Logger implementation with context awareness
+ *
+ * Tracks plugin/module/component hierarchy and supports child loggers.
+ */
+export class ContextLogger {
+    constructor(manager, context = {}, minLevel) {
+        this.manager = manager;
+        this.context = context;
+        this.minLevel = minLevel;
+        this.timers = new Map();
+    }
+    trace(message, meta) {
+        if (!this.isLevelEnabled(0))
+            return; // LogLevel.TRACE = 0
+        this.log(0, message, meta);
+    }
+    debug(message, meta) {
+        if (!this.isLevelEnabled(1))
+            return; // LogLevel.DEBUG = 1
+        this.log(1, message, meta);
+    }
+    info(message, meta) {
+        if (!this.isLevelEnabled(2))
+            return; // LogLevel.INFO = 2
+        this.log(2, message, meta);
+    }
+    warn(message, meta) {
+        if (!this.isLevelEnabled(3))
+            return; // LogLevel.WARN = 3
+        this.log(3, message, meta);
+    }
+    error(message, error, meta) {
+        if (!this.isLevelEnabled(4))
+            return; // LogLevel.ERROR = 4
+        this.log(4, message, {
+            ...meta,
+            error,
+            stack: error?.stack,
+        });
+    }
+    fatal(message, error, meta) {
+        if (!this.isLevelEnabled(5))
+            return; // LogLevel.FATAL = 5
+        this.log(5, message, {
+            ...meta,
+            error,
+            stack: error?.stack,
+        });
+    }
+    log(level, message, metadata) {
+        const entry = {
+            timestamp: Date.now(),
+            level,
+            message,
+            context: { ...this.context },
+            metadata,
+        };
+        this.manager.dispatch(entry);
+    }
+    child(context) {
+        return new ContextLogger(this.manager, { ...this.context, ...context }, this.minLevel);
+    }
+    scoped(context, fn) {
+        const scopedLogger = this.child(context);
+        fn(scopedLogger);
+    }
+    isLevelEnabled(level) {
+        return level >= this.minLevel;
+    }
+    time(label) {
+        this.timers.set(label, Date.now());
+    }
+    timeEnd(label) {
+        const start = this.timers.get(label);
+        if (start !== undefined) {
+            const duration = Date.now() - start;
+            this.debug(`${label}`, { duration, tags: ['performance'] });
+            this.timers.delete(label);
+        }
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './context-logger.js';
+export * from './log-manager.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,2 @@
+export * from './context-logger.js';
+export * from './log-manager.js';

package/dist/core/log-manager.d.ts

@@ -0,0 +1,41 @@
+import type { ILogManager, ILogger, ILogTransport, LogLevel, LogContext, LogEntry, LogManagerConfig, TransportConfig } from '@hamak/logging-api';
+/**
+ * Central log manager implementation
+ *
+ * Manages transports, creates loggers, and dispatches log entries.
+ */
+export declare class LogManager implements ILogManager {
+    private transports;
+    private transportConfigs;
+    private loggers;
+    private buffer;
+    private config;
+    private eventEmitter;
+    private flushTimer?;
+    constructor(config?: LogManagerConfig);
+    registerTransport(transport: ILogTransport, config?: TransportConfig): void;
+    unregisterTransport(id: string): void;
+    getTransport(id: string): ILogTransport | undefined;
+    listTransports(): ILogTransport[];
+    createLogger(context?: LogContext): ILogger;
+    getLogger(context?: LogContext): ILogger;
+    setGlobalLevel(level: LogLevel): void;
+    setPluginLevel(plugin: string, level: LogLevel): void;
+    setModuleLevel(module: string, level: LogLevel): void;
+    flush(): Promise<void>;
+    clearBuffer(): void;
+    on(event: 'log' | 'error' | 'flush', handler: (...args: any[]) => void): void;
+    off(event: string, handler: (...args: any[]) => void): void;
+    dispatch(entry: LogEntry): void;
+    /**
+     * Clean up resources
+     */
+    destroy(): Promise<void>;
+    private dispatchToTransports;
+    private shouldDispatch;
+    private resolveLevel;
+    private createCacheKey;
+    private startFlushTimer;
+    private handleTransportError;
+}
+//# sourceMappingURL=log-manager.d.ts.map

package/dist/core/log-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-manager.d.ts","sourceRoot":"","sources":["../../src/core/log-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,OAAO,EACP,aAAa,EACb,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,gBAAgB,EAChB,eAAe,EAChB,MAAM,oBAAoB,CAAC;AAI5B;;;;GAIG;AACH,qBAAa,UAAW,YAAW,WAAW;IAC5C,OAAO,CAAC,UAAU,CAAoC;IACtD,OAAO,CAAC,gBAAgB,CAAsC;IAC9D,OAAO,CAAC,OAAO,CAA8B;IAC7C,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,UAAU,CAAC,CAAiC;gBAExC,MAAM,GAAE,gBAAqB;IAezC,iBAAiB,CAAC,SAAS,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,IAAI;IAe3E,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAWrC,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAInD,cAAc,IAAI,aAAa,EAAE;IAIjC,YAAY,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO;IAK3C,SAAS,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO;IAUxC,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAIrC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI;IAIrD,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI/C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B5B,WAAW,IAAI,IAAI;IAInB,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,OAAO,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI;IAI7E,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI;IAI3D,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAoB/B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YAoBhB,oBAAoB;IAyBlC,OAAO,CAAC,cAAc;IA8CtB,OAAO,CAAC,YAAY;IAkBpB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,oBAAoB;CAa7B"}

package/dist/core/log-manager.js

@@ -0,0 +1,241 @@
+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 = {}) {
+        this.transports = new Map();
+        this.transportConfigs = new Map();
+        this.loggers = new Map();
+        this.buffer = [];
+        this.eventEmitter = new EventEmitter();
+        this.config = {
+            globalLevel: config.globalLevel ?? 2, // LogLevel.INFO
+            bufferSize: config.bufferSize ?? 1000,
+            flushInterval: config.flushInterval ?? 5000,
+            defaultTransports: config.defaultTransports ?? [],
+            pluginLevels: config.pluginLevels ?? {},
+            moduleLevels: config.moduleLevels ?? {},
+        };
+        if (this.config.flushInterval > 0) {
+            this.startFlushTimer();
+        }
+    }
+    registerTransport(transport, config) {
+        this.transports.set(transport.id, transport);
+        if (config) {
+            this.transportConfigs.set(transport.id, {
+                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;
+    }
+    async flush() {
+        const entries = this.buffer.splice(0);
+        if (entries.length === 0) {
+            return;
+        }
+        await Promise.all(entries.map(entry => this.dispatchToTransports(entry)));
+        await 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
+     */
+    async destroy() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        await this.flush();
+        await 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();
+    }
+    async dispatchToTransports(entry) {
+        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);
+            }
+        }
+        await Promise.all(promises);
+    }
+    shouldDispatch(entry, config, transport) {
+        if (config && config.enabled === false) {
+            return false;
+        }
+        if (config?.minLevel !== undefined && entry.level < config.minLevel) {
+            return false;
+        }
+        if (config?.maxLevel !== undefined && entry.level > config.maxLevel) {
+            return false;
+        }
+        if (config?.plugins && config.plugins.length > 0) {
+            if (!entry.context.plugin || !config.plugins.includes(entry.context.plugin)) {
+                return false;
+            }
+        }
+        if (config?.modules && config.modules.length > 0) {
+            if (!entry.context.module || !config.modules.includes(entry.context.module)) {
+                return false;
+            }
+        }
+        if (config?.tags && config.tags.length > 0) {
+            if (!entry.metadata?.tags || !config.tags.some(tag => entry.metadata.tags.includes(tag))) {
+                return false;
+            }
+        }
+        if (config?.filter && !config.filter(entry)) {
+            return false;
+        }
+        if (transport?.shouldLog && !transport.shouldLog(entry)) {
+            return false;
+        }
+        return true;
+    }
+    resolveLevel(context) {
+        if (context?.plugin) {
+            const pluginLevel = this.config.pluginLevels[context.plugin];
+            if (pluginLevel !== undefined) {
+                return pluginLevel;
+            }
+        }
+        if (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/core/context-logger.js

@@ -0,0 +1,74 @@
+/**
+ * Logger implementation with context awareness
+ *
+ * Tracks plugin/module/component hierarchy and supports child loggers.
+ */
+export class ContextLogger {
+    constructor(manager, context = {}, minLevel) {
+        this.manager = manager;
+        this.context = context;
+        this.minLevel = minLevel;
+        this.timers = new Map();
+    }
+    trace(message, meta) {
+        if (!this.isLevelEnabled(0))
+            return; // LogLevel.TRACE = 0
+        this.log(0, message, meta);
+    }
+    debug(message, meta) {
+        if (!this.isLevelEnabled(1))
+            return; // LogLevel.DEBUG = 1
+        this.log(1, message, meta);
+    }
+    info(message, meta) {
+        if (!this.isLevelEnabled(2))
+            return; // LogLevel.INFO = 2
+        this.log(2, message, meta);
+    }
+    warn(message, meta) {
+        if (!this.isLevelEnabled(3))
+            return; // LogLevel.WARN = 3
+        this.log(3, message, meta);
+    }
+    error(message, error, meta) {
+        if (!this.isLevelEnabled(4))
+            return; // LogLevel.ERROR = 4
+        this.log(4, message, Object.assign(Object.assign({}, meta), { error, stack: error === null || error === void 0 ? void 0 : error.stack }));
+    }
+    fatal(message, error, meta) {
+        if (!this.isLevelEnabled(5))
+            return; // LogLevel.FATAL = 5
+        this.log(5, message, Object.assign(Object.assign({}, meta), { error, stack: error === null || error === void 0 ? void 0 : error.stack }));
+    }
+    log(level, message, metadata) {
+        const entry = {
+            timestamp: Date.now(),
+            level,
+            message,
+            context: Object.assign({}, this.context),
+            metadata,
+        };
+        this.manager.dispatch(entry);
+    }
+    child(context) {
+        return new ContextLogger(this.manager, Object.assign(Object.assign({}, this.context), context), this.minLevel);
+    }
+    scoped(context, fn) {
+        const scopedLogger = this.child(context);
+        fn(scopedLogger);
+    }
+    isLevelEnabled(level) {
+        return level >= this.minLevel;
+    }
+    time(label) {
+        this.timers.set(label, Date.now());
+    }
+    timeEnd(label) {
+        const start = this.timers.get(label);
+        if (start !== undefined) {
+            const duration = Date.now() - start;
+            this.debug(`${label}`, { duration, tags: ['performance'] });
+            this.timers.delete(label);
+        }
+    }
+}

package/dist/es2015/core/index.js

@@ -0,0 +1,2 @@
+export * from './context-logger.js';
+export * from './log-manager.js';