@mks2508/better-logger 5.0.1 → 5.0.2

package/src/handlers/FileLogHandler.ts

@@ -1,169 +0,0 @@
-/**
- * @fileoverview File-based log handler for Advanced Logger
- */
-
-import type { ILogHandler, LogLevel, LogMetadata } from '../types/index.js';
-import { isNode, isBrowser } from '../utils/environment.js';
-import { safeSerialize } from '../utils/formatting.js';
-
-/**
- * Universal file-based log handler for persistent logging
- * Works in both Node.js (real files) and browser (localStorage)
- */
-export class FileLogHandler implements ILogHandler {
-    private filename: string;
-    private maxSize?: number;
-    private fs?: any; // Node.js fs module
-
-    constructor(filename: string = 'app.log', maxSize?: number) {
-        this.filename = filename;
-        this.maxSize = maxSize;
-        
-        // Load Node.js fs module if in Node environment
-        if (isNode) {
-            try {
-                this.fs = require('fs');
-            } catch (error) {
-                console.warn('FileLogHandler: Unable to load fs module:', error);
-            }
-        }
-    }
-
-    handle(level: LogLevel, message: string, args: any[], metadata: LogMetadata): void {
-        const logEntry = {
-            timestamp: metadata.timestamp,
-            level: level.toUpperCase(),
-            prefix: metadata.prefix,
-            message,
-            args: args.slice(1).map(arg => safeSerialize(arg)),
-            location: metadata.stackInfo,
-        };
-
-        const logLine = this.formatLogLine(logEntry);
-
-        if (isNode && this.fs) {
-            this.writeToFileNode(logLine);
-        } else if (isBrowser) {
-            this.writeToFileLocal(logLine);
-        } else {
-            // Fallback - just console output
-            console.log(`[FILE-LOG] ${logLine}`);
-        }
-    }
-
-    /**
-     * Format log entry as a single line for file storage
-     */
-    private formatLogLine(entry: any): string {
-        const parts = [
-            entry.timestamp,
-            `[${entry.level}]`,
-            entry.prefix ? `[${entry.prefix}]` : '',
-            entry.message
-        ].filter(Boolean);
-
-        let line = parts.join(' ');
-        
-        if (entry.args && entry.args.length > 0) {
-            line += ' ' + entry.args.map((arg: any) => 
-                typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
-            ).join(' ');
-        }
-        
-        if (entry.location) {
-            line += ` (${entry.location.file}:${entry.location.line}:${entry.location.column})`;
-        }
-        
-        return line;
-    }
-
-    /**
-     * Write to actual file in Node.js environment
-     */
-    private writeToFileNode(logLine: string): void {
-        if (!this.fs) return;
-
-        try {
-            // Check file size if maxSize is set
-            if (this.maxSize) {
-                try {
-                    const stats = this.fs.statSync(this.filename);
-                    if (stats.size > this.maxSize) {
-                        // Simple rotation: backup current file and start fresh
-                        const backupName = `${this.filename}.bak`;
-                        this.fs.renameSync(this.filename, backupName);
-                    }
-                } catch (error) {
-                    // File doesn't exist yet, that's fine
-                }
-            }
-
-            // Append to file
-            this.fs.appendFileSync(this.filename, logLine + '\n', 'utf8');
-        } catch (error) {
-            console.error('FileLogHandler: Failed to write to file:', error);
-        }
-    }
-
-    /**
-     * Write to localStorage in browser environment
-     */
-    private writeToFileLocal(logLine: string): void {
-        try {
-            const storageKey = `logger_${this.filename}`;
-            const existingLogs = localStorage.getItem(storageKey) || '';
-            
-            let newLogs = existingLogs;
-            if (existingLogs.length > 0) {
-                newLogs += '\n';
-            }
-            newLogs += logLine;
-            
-            // Simple size management - keep last 1000 lines max
-            if (this.maxSize || newLogs.split('\n').length > 1000) {
-                const lines = newLogs.split('\n');
-                const maxLines = this.maxSize ? Math.floor(this.maxSize / 100) : 1000;
-                if (lines.length > maxLines) {
-                    newLogs = lines.slice(-maxLines).join('\n');
-                }
-            }
-            
-            localStorage.setItem(storageKey, newLogs);
-        } catch (error) {
-            console.error('FileLogHandler: Failed to write to localStorage:', error);
-        }
-    }
-
-    /**
-     * Get stored logs (useful for debugging)
-     */
-    getLogs(): string | null {
-        if (isNode && this.fs) {
-            try {
-                return this.fs.readFileSync(this.filename, 'utf8');
-            } catch (error) {
-                return null;
-            }
-        } else if (isBrowser) {
-            const storageKey = `logger_${this.filename}`;
-            return localStorage.getItem(storageKey);
-        }
-        return null;
-    }
-
-    /**
-     * Clear stored logs
-     */
-    clearLogs(): void {
-        if (isNode && this.fs) {
-            try {
-                this.fs.writeFileSync(this.filename, '', 'utf8');
-            } catch (error) {
-                console.error('FileLogHandler: Failed to clear file:', error);
-            }
-        } else if (isBrowser) {
-            const storageKey = `logger_${this.filename}`;
-            localStorage.removeItem(storageKey);
-        }
-    }
-}

package/src/handlers/RemoteLogHandler.ts

@@ -1,42 +0,0 @@
-/**
- * @fileoverview Remote log handler for Advanced Logger
- */
-
-import type { ILogHandler, LogLevel, LogMetadata } from '../types/index.js';
-
-/**
- * Remote log handler for sending logs to external services
- */
-export class RemoteLogHandler implements ILogHandler {
-    private endpoint: string;
-    private apiKey?: string;
-
-    constructor(endpoint: string, apiKey?: string) {
-        this.endpoint = endpoint;
-        this.apiKey = apiKey;
-    }
-
-    async handle(level: LogLevel, message: string, args: any[], metadata: LogMetadata): Promise<void> {
-        try {
-            const payload = {
-                timestamp: metadata.timestamp,
-                level,
-                message,
-                prefix: metadata.prefix,
-                location: metadata.stackInfo,
-                additional: args.slice(1),
-            };
-
-            await fetch(this.endpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...(this.apiKey && { 'Authorization': `Bearer ${this.apiKey}` }),
-                },
-                body: JSON.stringify(payload),
-            });
-        } catch (error) {
-            // Silently fail to avoid infinite logging loops
-        }
-    }
-}

package/src/hooks/HookManager.ts

@@ -1,177 +0,0 @@
-import type {
-    HookLogEntry,
-    HookEvent,
-    HookCallback,
-    MiddlewareFn,
-    HookRegistration,
-    MiddlewareRegistration,
-    IHookManager
-} from '../types/index.js';
-
-function generateId(): string {
-    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-}
-
-export class HookManager implements IHookManager {
-    private hooks: Map<HookEvent, HookRegistration[]> = new Map();
-    private middlewares: MiddlewareRegistration[] = [];
-
-    constructor() {
-        this.hooks.set('beforeLog', []);
-        this.hooks.set('afterLog', []);
-        this.hooks.set('onError', []);
-    }
-
-    on(event: HookEvent, callback: HookCallback, priority: number = 50): () => void {
-        const registration: HookRegistration = {
-            id: generateId(),
-            event,
-            callback,
-            priority,
-            once: false
-        };
-
-        const hooks = this.hooks.get(event)!;
-        hooks.push(registration);
-        hooks.sort((a, b) => b.priority - a.priority);
-
-        return () => this.removeHook(event, registration.id);
-    }
-
-    once(event: HookEvent, callback: HookCallback, priority: number = 50): () => void {
-        const registration: HookRegistration = {
-            id: generateId(),
-            event,
-            callback,
-            priority,
-            once: true
-        };
-
-        const hooks = this.hooks.get(event)!;
-        hooks.push(registration);
-        hooks.sort((a, b) => b.priority - a.priority);
-
-        return () => this.removeHook(event, registration.id);
-    }
-
-    off(event: HookEvent, callback: HookCallback): boolean {
-        const hooks = this.hooks.get(event);
-        if (!hooks) return false;
-
-        const index = hooks.findIndex(h => h.callback === callback);
-        if (index >= 0) {
-            hooks.splice(index, 1);
-            return true;
-        }
-        return false;
-    }
-
-    private removeHook(event: HookEvent, id: string): void {
-        const hooks = this.hooks.get(event);
-        if (hooks) {
-            const index = hooks.findIndex(h => h.id === id);
-            if (index >= 0) {
-                hooks.splice(index, 1);
-            }
-        }
-    }
-
-    use(middleware: MiddlewareFn, priority: number = 50): () => void {
-        const registration: MiddlewareRegistration = {
-            id: generateId(),
-            fn: middleware,
-            priority
-        };
-
-        this.middlewares.push(registration);
-        this.middlewares.sort((a, b) => b.priority - a.priority);
-
-        return () => {
-            const index = this.middlewares.findIndex(m => m.id === registration.id);
-            if (index >= 0) {
-                this.middlewares.splice(index, 1);
-            }
-        };
-    }
-
-    async emit(event: HookEvent, entry: HookLogEntry): Promise<HookLogEntry> {
-        const hooks = this.hooks.get(event) || [];
-        let currentEntry = { ...entry };
-        const toRemove: string[] = [];
-
-        for (const hook of hooks) {
-            try {
-                const result = await hook.callback(currentEntry);
-                if (result) {
-                    currentEntry = { ...currentEntry, ...result };
-                }
-                if (hook.once) {
-                    toRemove.push(hook.id);
-                }
-            } catch (error) {
-                if (event !== 'onError') {
-                    await this.emit('onError', {
-                        ...currentEntry,
-                        error,
-                        hookEvent: event
-                    } as HookLogEntry);
-                }
-            }
-        }
-
-        toRemove.forEach(id => this.removeHook(event, id));
-        return currentEntry;
-    }
-
-    async process(entry: HookLogEntry): Promise<HookLogEntry> {
-        let currentEntry = { ...entry };
-
-        currentEntry = await this.emit('beforeLog', currentEntry);
-
-        if (this.middlewares.length > 0) {
-            let index = 0;
-
-            const executeNext = async (): Promise<void> => {
-                if (index < this.middlewares.length) {
-                    const middleware = this.middlewares[index++];
-                    if (middleware) {
-                        await middleware.fn(currentEntry, executeNext);
-                    }
-                }
-            };
-
-            await executeNext();
-        }
-
-        return currentEntry;
-    }
-
-    async afterProcess(entry: HookLogEntry): Promise<void> {
-        await this.emit('afterLog', entry);
-    }
-
-    clear(): void {
-        this.hooks.forEach(hooks => hooks.length = 0);
-        this.middlewares.length = 0;
-    }
-
-    getStats(): { hooks: Record<HookEvent, number>; middlewares: number } {
-        return {
-            hooks: {
-                beforeLog: this.hooks.get('beforeLog')?.length || 0,
-                afterLog: this.hooks.get('afterLog')?.length || 0,
-                onError: this.hooks.get('onError')?.length || 0
-            },
-            middlewares: this.middlewares.length
-        };
-    }
-}
-
-let _defaultHookManager: HookManager | null = null;
-
-export function getDefaultHookManager(): HookManager {
-    if (!_defaultHookManager) {
-        _defaultHookManager = new HookManager();
-    }
-    return _defaultHookManager;
-}