@mks2508/better-logger 0.14.0-alpha.2 → 1.1.0

package/dist/handlers/ExportLogHandler.js

@@ -1,516 +0,0 @@
-/**
- * @fileoverview Export and clipboard log handler for Advanced Logger
- */
-import { parseTimeInput, formatDisplayTime, safeStringify, escapeHtml, generateLogId } from '../utils/index.js';
-import { BUFFER_LIMITS } from '../constants.js';
-/**
- * Export log handler with circular buffer and multiple export formats
- */
-export class ExportLogHandler {
-    buffer = [];
-    maxSize;
-    groupDepth = 0;
-    currentGroup;
-    constructor(maxSize = BUFFER_LIMITS.DEFAULT_SIZE) {
-        this.maxSize = Math.min(Math.max(maxSize, BUFFER_LIMITS.MIN_SIZE), BUFFER_LIMITS.MAX_SIZE);
-    }
-    /**
-     * Handle incoming log and store in buffer
-     */
-    handle(level, message, args, metadata) {
-        const entry = {
-            id: generateLogId(),
-            timestamp: metadata.timestamp,
-            level,
-            prefix: metadata.prefix,
-            message,
-            args,
-            location: metadata.stackInfo,
-            groupInfo: this.groupDepth > 0 ? {
-                depth: this.groupDepth,
-                groupName: this.currentGroup
-            } : undefined
-        };
-        // Add to circular buffer
-        this.buffer.push(entry);
-        if (this.buffer.length > this.maxSize) {
-            this.buffer.shift(); // Remove oldest entry
-        }
-    }
-    /**
-     * Set group tracking for nested logs
-     */
-    setGroupInfo(depth, groupName) {
-        this.groupDepth = depth;
-        this.currentGroup = groupName;
-    }
-    /**
-     * Get buffer statistics
-     */
-    getBufferStats() {
-        const levelCounts = this.buffer.reduce((acc, entry) => {
-            const currentCount = acc[entry.level] ? acc[entry.level] : 0;
-            acc[entry.level] = currentCount + 1;
-            return acc;
-        }, {});
-        let oldestLog;
-        let newestLog;
-        if (this.buffer.length > 0) {
-            const firstEntry = this.buffer[0];
-            const lastEntry = this.buffer[this.buffer.length - 1];
-            if (firstEntry && firstEntry.timestamp) {
-                oldestLog = new Date(firstEntry.timestamp);
-            }
-            if (lastEntry && lastEntry.timestamp) {
-                newestLog = new Date(lastEntry.timestamp);
-            }
-        }
-        return {
-            size: this.buffer.length,
-            maxSize: this.maxSize,
-            usage: (this.buffer.length / this.maxSize) * 100,
-            oldestLog,
-            newestLog,
-            levelCounts: {
-                debug: levelCounts.debug ? levelCounts.debug : 0,
-                info: levelCounts.info ? levelCounts.info : 0,
-                warn: levelCounts.warn ? levelCounts.warn : 0,
-                error: levelCounts.error ? levelCounts.error : 0,
-                critical: levelCounts.critical ? levelCounts.critical : 0
-            }
-        };
-    }
-    /**
-     * Clear the buffer
-     */
-    clearBuffer() {
-        this.buffer = [];
-    }
-    /**
-     * Set buffer size (with limits)
-     */
-    setBufferSize(size) {
-        this.maxSize = Math.min(Math.max(size, BUFFER_LIMITS.MIN_SIZE), BUFFER_LIMITS.MAX_SIZE);
-        // Trim buffer if new size is smaller
-        if (this.buffer.length > this.maxSize) {
-            this.buffer = this.buffer.slice(-this.maxSize);
-        }
-    }
-    /**
-     * Filter logs based on criteria
-     */
-    filterLogs(filters = {}) {
-        let filtered = [...this.buffer];
-        // Filter by levels
-        if (filters.levels?.length) {
-            filtered = filtered.filter(entry => filters.levels.includes(entry.level));
-        }
-        // Filter by prefixes
-        if (filters.prefixes?.length) {
-            filtered = filtered.filter(entry => entry.prefix && filters.prefixes.includes(entry.prefix));
-        }
-        // Exclude prefixes
-        if (filters.excludePrefixes?.length) {
-            filtered = filtered.filter(entry => !entry.prefix || !filters.excludePrefixes.includes(entry.prefix));
-        }
-        // Filter by time range
-        if (filters.since) {
-            const sinceDate = parseTimeInput(filters.since);
-            filtered = filtered.filter(entry => new Date(entry.timestamp) >= sinceDate);
-        }
-        if (filters.until) {
-            const untilDate = parseTimeInput(filters.until);
-            filtered = filtered.filter(entry => new Date(entry.timestamp) <= untilDate);
-        }
-        // Filter by stack trace presence
-        if (filters.withStackTrace) {
-            filtered = filtered.filter(entry => entry.location);
-        }
-        // Filter errors only
-        if (filters.errorsOnly) {
-            filtered = filtered.filter(entry => entry.level === 'error' || entry.level === 'critical');
-        }
-        // Search in messages
-        if (filters.search) {
-            const searchTerm = filters.search.toLowerCase();
-            filtered = filtered.filter(entry => entry.message.toLowerCase().includes(searchTerm) ||
-                entry.args.some(arg => String(arg).toLowerCase().includes(searchTerm)));
-        }
-        // Limit results
-        if (filters.last) {
-            filtered = filtered.slice(-filters.last);
-        }
-        if (filters.first) {
-            filtered = filtered.slice(0, filters.first);
-        }
-        return filtered;
-    }
-    /**
-     * Export logs in JSON format
-     */
-    exportJSON(logs, options) {
-        const data = logs.map(entry => ({
-            timestamp: entry.timestamp,
-            level: entry.level,
-            prefix: entry.prefix,
-            message: entry.message,
-            ...(options.minimal ? {} : {
-                args: entry.args.slice(1),
-                location: entry.location,
-                groupInfo: entry.groupInfo
-            })
-        }));
-        return options.compact
-            ? JSON.stringify(data)
-            : JSON.stringify(data, null, 2);
-    }
-    /**
-     * Export logs in CSV format
-     */
-    exportCSV(logs, options) {
-        const headers = options.minimal
-            ? ['Timestamp', 'Level', 'Prefix', 'Message']
-            : ['Timestamp', 'Level', 'Prefix', 'Message', 'File', 'Line', 'Args'];
-        const rows = logs.map(entry => {
-            const baseRow = [
-                formatDisplayTime(new Date(entry.timestamp), 'full'),
-                entry.level.toUpperCase(),
-                entry.prefix || '',
-                `"${entry.message.replace(/"/g, '""')}"`
-            ];
-            if (!options.minimal) {
-                baseRow.push(entry.location?.file || '', entry.location?.line?.toString() || '', `"${safeStringify(entry.args.slice(1)).replace(/"/g, '""')}"`);
-            }
-            return baseRow;
-        });
-        return [headers.join(','), ...rows.map(row => row.join(','))].join('\n');
-    }
-    /**
-     * Export logs in Markdown format
-     */
-    exportMarkdown(logs, options) {
-        const now = new Date();
-        let content = `# Log Export - ${formatDisplayTime(now, 'full')}\n\n`;
-        // Add summary if not minimal
-        if (!options.minimal) {
-            const summary = this.getBufferStats();
-            content += `## Summary\n`;
-            content += `- **Total logs**: ${logs.length}\n`;
-            content += `- **Errors**: ${summary.levelCounts.error + summary.levelCounts.critical}\n`;
-            content += `- **Warnings**: ${summary.levelCounts.warn}\n\n`;
-        }
-        // Group by level if specified
-        if (options.groupBy === 'level') {
-            const grouped = logs.reduce((acc, entry) => {
-                const level = entry.level;
-                if (!acc[level]) {
-                    acc[level] = [];
-                }
-                // We just ensured the array exists above
-                const levelArray = acc[level];
-                if (levelArray) {
-                    levelArray.push(entry);
-                }
-                return acc;
-            }, {});
-            Object.entries(grouped).forEach(([level, entries]) => {
-                const emoji = this.getLevelEmoji(level);
-                content += `## ${emoji} ${level.toUpperCase()} (${entries.length})\n\n`;
-                entries.forEach(entry => {
-                    const time = formatDisplayTime(new Date(entry.timestamp), 'time-only');
-                    const location = entry.location ? ` (${entry.location.file}:${entry.location.line})` : '';
-                    const prefix = entry.prefix ? ` **${entry.prefix}**:` : '';
-                    content += `- \`${time}\`${prefix} ${entry.message}${location}\n`;
-                });
-                content += '\n';
-            });
-        }
-        else {
-            content += '## Logs\n\n';
-            logs.forEach(entry => {
-                const time = formatDisplayTime(new Date(entry.timestamp), 'time-only');
-                const emoji = this.getLevelEmoji(entry.level);
-                const location = entry.location ? ` (${entry.location.file}:${entry.location.line})` : '';
-                const prefix = entry.prefix ? ` **${entry.prefix}**:` : '';
-                content += `- \`${time}\` ${emoji}${prefix} ${entry.message}${location}\n`;
-            });
-        }
-        return content;
-    }
-    /**
-     * Export logs in plain text format
-     */
-    exportPlain(logs, options) {
-        return logs.map(entry => {
-            const time = formatDisplayTime(new Date(entry.timestamp), options.minimal ? 'time-only' : 'short');
-            const level = entry.level.toUpperCase().padEnd(8);
-            const prefix = entry.prefix ? `[${entry.prefix}] ` : '';
-            const location = (!options.minimal && entry.location) ? ` (${entry.location.file}:${entry.location.line})` : '';
-            return `${time} ${level} ${prefix}${entry.message}${location}`;
-        }).join('\n');
-    }
-    /**
-     * Export logs in HTML format
-     */
-    exportHTML(logs, _options) {
-        const title = `Log Export - ${formatDisplayTime(new Date(), 'full')}`;
-        let html = `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>${title}</title>
-    <style>
-        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 20px; line-height: 1.6; }
-        .header { border-bottom: 2px solid #ddd; padding-bottom: 20px; margin-bottom: 20px; }
-        .log-entry { margin: 5px 0; padding: 8px; border-radius: 4px; font-family: 'Monaco', 'Consolas', monospace; }
-        .timestamp { color: #666; font-size: 0.9em; }
-        .level { font-weight: bold; padding: 2px 6px; border-radius: 3px; margin: 0 8px; }
-        .prefix { background: #2d3748; color: #e2e8f0; padding: 2px 6px; border-radius: 3px; margin: 0 8px; }
-        .location { color: #718096; font-size: 0.9em; }
-        .debug { background: #f0f4ff; }
-        .info { background: #f0f9ff; }
-        .warn { background: #fffbeb; }
-        .error { background: #fef2f2; }
-        .critical { background: #fef2f2; border-left: 4px solid #dc2626; }
-        .level.debug { background: #667eea; color: white; }
-        .level.info { background: #74b9ff; color: white; }
-        .level.warn { background: #fdcb6e; color: #2d3436; }
-        .level.error { background: #e84393; color: white; }
-        .level.critical { background: #ff3838; color: white; }
-    </style>
-</head>
-<body>
-    <div class="header">
-        <h1>${title}</h1>
-        <p>Generated by Advanced Logger v2.0.0</p>
-    </div>
-    <div class="logs">`;
-        logs.forEach(entry => {
-            const time = formatDisplayTime(new Date(entry.timestamp), 'full');
-            const location = entry.location ? ` <span class="location">(${escapeHtml(entry.location.file)}:${entry.location.line})</span>` : '';
-            const prefix = entry.prefix ? ` <span class="prefix">${escapeHtml(entry.prefix)}</span>` : '';
-            html += `
-        <div class="log-entry ${entry.level}">
-            <span class="timestamp">${time}</span>
-            <span class="level ${entry.level}">${entry.level.toUpperCase()}</span>
-            ${prefix}
-            <span class="message">${escapeHtml(entry.message)}</span>
-            ${location}
-        </div>`;
-        });
-        html += `
-    </div>
-</body>
-</html>`;
-        return html;
-    }
-    /**
-     * Get emoji for log level
-     */
-    getLevelEmoji(level) {
-        const emojis = {
-            debug: '🐞',
-            info: 'ℹ️',
-            warn: '⚠️',
-            error: '❌',
-            critical: '🔥'
-        };
-        return emojis[level] || '';
-    }
-    /**
-     * Main export function
-     */
-    export(format, filters = {}, options = {}) {
-        const filteredLogs = this.filterLogs(filters);
-        let data;
-        switch (format) {
-            case 'json':
-                data = this.exportJSON(filteredLogs, options);
-                break;
-            case 'csv':
-                data = this.exportCSV(filteredLogs, options);
-                break;
-            case 'markdown':
-                data = this.exportMarkdown(filteredLogs, options);
-                break;
-            case 'plain':
-                data = this.exportPlain(filteredLogs, options);
-                break;
-            case 'html':
-                data = this.exportHTML(filteredLogs, options);
-                break;
-            default:
-                throw new Error(`Unsupported export format: ${format}`);
-        }
-        return {
-            format,
-            data,
-            metadata: {
-                totalLogs: this.buffer.length,
-                filteredLogs: filteredLogs.length,
-                exportedAt: new Date().toISOString(),
-                filters,
-                options
-            }
-        };
-    }
-    /**
-     * Copy to clipboard with fallback
-     */
-    async copyToClipboard(format, filters = {}, options = {}) {
-        const result = this.export(format, filters, options);
-        try {
-            if (navigator.clipboard && window.isSecureContext) {
-                await navigator.clipboard.writeText(result.data);
-                return true;
-            }
-            else {
-                // Fallback for non-secure contexts
-                const textArea = document.createElement('textarea');
-                textArea.value = result.data;
-                textArea.style.position = 'fixed';
-                textArea.style.opacity = '0';
-                document.body.appendChild(textArea);
-                textArea.focus();
-                textArea.select();
-                const success = document.execCommand('copy');
-                document.body.removeChild(textArea);
-                return success;
-            }
-        }
-        catch (error) {
-            console.error('Failed to copy to clipboard:', error);
-            return false;
-        }
-    }
-    /**
-     * Get all logs (for debugging)
-     */
-    getAllLogs() {
-        return [...this.buffer];
-    }
-    /**
-     * Save export to file with download prompt
-     */
-    async saveToFile(format, filters = {}, options = {}) {
-        try {
-            const result = this.export(format, filters, options);
-            const blob = new Blob([result.data], {
-                type: this.getMimeType(format)
-            });
-            const url = URL.createObjectURL(blob);
-            const a = document.createElement('a');
-            const filename = this.generateFilename(format, filters);
-            a.href = url;
-            a.download = filename;
-            a.style.display = 'none';
-            document.body.appendChild(a);
-            a.click();
-            document.body.removeChild(a);
-            URL.revokeObjectURL(url);
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to save file:', error);
-            return false;
-        }
-    }
-    /**
-     * Get MIME type for format
-     */
-    getMimeType(format) {
-        const mimeTypes = {
-            json: 'application/json',
-            csv: 'text/csv',
-            markdown: 'text/markdown',
-            plain: 'text/plain',
-            html: 'text/html'
-        };
-        return mimeTypes[format] || 'text/plain';
-    }
-    /**
-     * Generate filename with timestamp
-     */
-    generateFilename(format, filters) {
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
-        const prefix = filters.prefixes?.length === 1 ? `_${filters.prefixes[0]}` : '';
-        const extension = format === 'markdown' ? 'md' : format;
-        return `logs${prefix}_${timestamp}.${extension}`;
-    }
-    /**
-     * Stream logs to external endpoint
-     */
-    async streamToEndpoint(endpoint, filters = {}, options = {}) {
-        try {
-            const logs = this.filterLogs(filters);
-            const batchSize = options.batchSize || 100;
-            const format = options.format || 'json';
-            // Send in batches
-            for (let i = 0; i < logs.length; i += batchSize) {
-                const batch = logs.slice(i, i + batchSize);
-                const result = this.export(format, {}, { compact: true });
-                const headers = {
-                    'Content-Type': 'application/json'
-                };
-                if (options.apiKey) {
-                    headers['Authorization'] = `Bearer ${options.apiKey}`;
-                }
-                const response = await fetch(endpoint, {
-                    method: 'POST',
-                    headers,
-                    body: JSON.stringify({
-                        logs: batch,
-                        metadata: {
-                            batchIndex: Math.floor(i / batchSize),
-                            totalBatches: Math.ceil(logs.length / batchSize),
-                            timestamp: new Date().toISOString()
-                        }
-                    })
-                });
-                if (!response.ok) {
-                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-                }
-            }
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to stream logs:', error);
-            return false;
-        }
-    }
-    /**
-     * Create export with metadata enrichment
-     */
-    exportWithMetadata(format, filters = {}, options = {}) {
-        const baseResult = this.export(format, filters, options);
-        const bufferStats = this.getBufferStats();
-        return {
-            ...baseResult,
-            metadata: {
-                ...baseResult.metadata,
-                bufferStats: bufferStats,
-                performance: {
-                    memoryUsage: this.estimateMemoryUsage(),
-                    processingTime: Date.now()
-                },
-                system: {
-                    userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : 'Node.js',
-                    timestamp: new Date().toISOString(),
-                    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
-                }
-            }
-        };
-    }
-    /**
-     * Estimate memory usage of buffer
-     */
-    estimateMemoryUsage() {
-        const sampleEntry = this.buffer[0];
-        if (!sampleEntry)
-            return 0;
-        // Rough estimation: JSON.stringify size * buffer length
-        const sampleSize = JSON.stringify(sampleEntry).length;
-        return sampleSize * this.buffer.length;
-    }
-}

package/dist/handlers/FileLogHandler.js

@@ -1,156 +0,0 @@
-/**
- * @fileoverview File-based log handler for Advanced Logger
- */
-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 {
-    filename;
-    maxSize;
-    fs; // Node.js fs module
-    constructor(filename = 'app.log', maxSize) {
-        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, message, args, metadata) {
-        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
-     */
-    formatLogLine(entry) {
-        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) => 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
-     */
-    writeToFileNode(logLine) {
-        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
-     */
-    writeToFileLocal(logLine) {
-        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() {
-        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() {
-        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);
-        }
-    }
-}