@mks2508/better-logger 0.0.2-alpha.2 → 0.3.0

package/src/core.ts

@@ -16,14 +16,33 @@ import type {
     TimerEntry
 } from './types/index.js';
 
-// Core utilities only
+// Core utilities
 import {
     parseStackTrace,
     formatTimestamp
 } from './utils/index.js';
 
-// Minimal constants
-import { DEFAULT_CONFIG } from './constants.js';
+// Universal formatting and environment detection
+import {
+    createPlainOutput,
+    getConsoleMethod,
+    createLogEntry,
+    formatTablePlain,
+    safeSerialize
+} from './utils/formatting.js';
+
+import {
+    isBrowser,
+    isNode,
+    getRuntimeEnvironment,
+    supportsColors,
+    supportsCSSColors
+} from './utils/environment.js';
+
+import { createStyledOutput } from './utils/output.js';
+
+// Constants
+import { DEFAULT_CONFIG, LEVEL_STYLES } from './constants.js';
 
 /**
  * Minimal Logger class with core functionality only
@@ -52,10 +71,11 @@ export class CoreLogger {
         this.config = {
             ...DEFAULT_CONFIG,
             ...config,
-            // Force disable advanced features for core module
-            enableColors: false,
+            // Auto-configure based on environment
+            enableColors: config.enableColors ?? (isBrowser ? true : false),
             enableTimestamps: config.enableTimestamps ?? true,
             enableStackTrace: config.enableStackTrace ?? false,
+            autoDetectTheme: config.autoDetectTheme ?? true
         };
     }
 
@@ -85,7 +105,7 @@ export class CoreLogger {
     /**
      * Creates a scoped logger with a specific prefix
      */
-    createScopedLogger(prefix: string): CoreLogger {
+    scope(prefix: string): CoreLogger {
         const scopedLogger = new CoreLogger(this.config);
         scopedLogger.scopedPrefix = prefix;
         scopedLogger.handlers = [...this.handlers];
@@ -119,49 +139,53 @@ export class CoreLogger {
     }
 
     /**
-     * Core logging method with minimal formatting
+     * Core logging method with universal formatting
      */
     private log(level: LogLevel, ...args: any[]): void {
         if (!this.shouldLog(level)) return;
 
         const prefix = this.getEffectivePrefix();
-        const timestamp = this.config.enableTimestamps ? formatTimestamp() : null;
+        const message = String(args[0] || '');
         const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+        const consoleMethod = getConsoleMethod(level);
         
-        // Simple formatting without CSS styling
-        const parts: string[] = [];
-        
-        if (timestamp) {
-            parts.push(`[${timestamp.slice(11, 23)}]`);
-        }
-        
-        parts.push(`[${level.toUpperCase()}]`);
-        
-        if (prefix) {
-            parts.push(`[${prefix}]`);
-        }
-
-        const groupIndent = '  '.repeat(this.groupDepth);
-        const logPrefix = groupIndent + parts.join(' ');
-        
-        // Output to console with simple formatting
-        console.log(logPrefix, ...args);
-        
-        if (stackInfo && this.config.enableStackTrace) {
-            console.log(`    at ${stackInfo.file}:${stackInfo.line}:${stackInfo.column}`);
+        // Choose formatting based on environment and configuration
+        if (isBrowser && this.config.enableColors && supportsCSSColors()) {
+            // Browser with CSS styling
+            try {
+                const [format, ...styles] = createStyledOutput(
+                    level,
+                    LEVEL_STYLES,
+                    prefix,
+                    message,
+                    stackInfo,
+                    this.config.autoDetectTheme
+                );
+                console[consoleMethod](format, ...styles, ...args.slice(1));
+            } catch (error) {
+                // Fallback to plain text if CSS fails
+                const output = createPlainOutput(level, message, prefix, stackInfo);
+                console[consoleMethod](output, ...args.slice(1));
+            }
+        } else {
+            // Node.js or browser without colors - use plain text
+            const groupIndent = '  '.repeat(this.groupDepth);
+            const output = groupIndent + createPlainOutput(level, message, prefix, stackInfo);
+            console[consoleMethod](output, ...args.slice(1));
         }
 
-        // Call custom handlers
+        // Call custom handlers with structured metadata
+        const logEntry = createLogEntry(level, message, args, prefix, stackInfo);
         const metadata: LogMetadata = {
-            timestamp: timestamp || formatTimestamp(),
+            timestamp: logEntry.timestamp,
             level,
             prefix,
-            stackInfo: stackInfo || undefined,
+            stackInfo: logEntry.location,
         };
 
         this.handlers.forEach(handler => {
             try {
-                handler.handle(level, String(args[0] || ''), args, metadata);
+                handler.handle(level, message, args, metadata);
             } catch (error) {
                 console.error('Log handler failed:', error);
             }
@@ -222,12 +246,21 @@ export class CoreLogger {
         if (!this.shouldLog('info')) return;
 
         const prefix = this.getEffectivePrefix();
-        console.log(`[TABLE]${prefix ? ` [${prefix}]` : ''}:`);
+        const tableHeader = `[TABLE]${prefix ? ` [${prefix}]` : ''}:`;
         
-        if (columns) {
-            console.table(data, columns);
+        if (isBrowser && typeof console.table === 'function') {
+            // Browser has native table support
+            console.log(tableHeader);
+            if (columns) {
+                console.table(data, columns);
+            } else {
+                console.table(data);
+            }
         } else {
-            console.table(data);
+            // Node.js or fallback - use plain text formatting
+            console.log(tableHeader);
+            const tableText = formatTablePlain(data, columns);
+            console.log(tableText);
         }
     }
 
@@ -238,10 +271,17 @@ export class CoreLogger {
         const prefix = this.getEffectivePrefix();
         const fullLabel = `${prefix ? `[${prefix}] ` : ''}${label}`;
         
-        if (collapsed) {
-            console.groupCollapsed(fullLabel);
+        if (isBrowser && console.group && console.groupCollapsed) {
+            // Browser supports native grouping
+            if (collapsed) {
+                console.groupCollapsed(fullLabel);
+            } else {
+                console.group(fullLabel);
+            }
         } else {
-            console.group(fullLabel);
+            // Node.js fallback - just log the group label
+            const groupStart = '┌─ ' + fullLabel;
+            console.log(groupStart);
         }
         
         this.groupDepth++;
@@ -252,7 +292,13 @@ export class CoreLogger {
      */
     groupEnd(): void {
         if (this.groupDepth > 0) {
-            console.groupEnd();
+            if (isBrowser && console.groupEnd) {
+                console.groupEnd();
+            } else {
+                // Node.js fallback - log group end
+                const groupEnd = '└─ (end group)';
+                console.log(groupEnd);
+            }
             this.groupDepth--;
         }
     }
@@ -261,12 +307,17 @@ export class CoreLogger {
      * Starts a timer with the given label
      */
     time(label: string): void {
+        const startTime = this.getPerformanceNow();
         const timer: TimerEntry = {
             label,
-            startTime: performance.now(),
+            startTime,
         };
         this.timers.set(label, timer);
-        console.log(`[TIMER] Started: ${label}`);
+        
+        const prefix = this.getEffectivePrefix();
+        const message = `Timer started: ${label}`;
+        const output = createPlainOutput('info', message, prefix);
+        console.log(output);
     }
 
     /**
@@ -279,9 +330,31 @@ export class CoreLogger {
             return;
         }
 
-        const elapsed = performance.now() - timer.startTime;
+        const elapsed = this.getPerformanceNow() - timer.startTime;
         this.timers.delete(label);
-        console.log(`[TIMER] ${label}: ${elapsed.toFixed(2)}ms`);
+        
+        const prefix = this.getEffectivePrefix();
+        const message = `Timer ended: ${label} - ${elapsed.toFixed(2)}ms`;
+        const output = createPlainOutput('info', message, prefix);
+        console.log(output);
+    }
+
+    /**
+     * Gets performance.now() or fallback for older environments
+     */
+    private getPerformanceNow(): number {
+        if (typeof performance !== 'undefined' && performance.now) {
+            return performance.now();
+        }
+        
+        if (isNode && process.hrtime) {
+            // Node.js high-resolution time
+            const [seconds, nanoseconds] = process.hrtime();
+            return seconds * 1000 + nanoseconds / 1000000;
+        }
+        
+        // Fallback to Date.now()
+        return Date.now();
     }
 }
 
@@ -303,7 +376,7 @@ export const groupEnd = () => coreLogger.groupEnd();
 export const time = (label: string) => coreLogger.time(label);
 export const timeEnd = (label: string) => coreLogger.timeEnd(label);
 export const setGlobalPrefix = (prefix: string) => coreLogger.setGlobalPrefix(prefix);
-export const createScopedLogger = (prefix: string) => coreLogger.createScopedLogger(prefix);
+export const scope = (prefix: string) => coreLogger.scope(prefix);
 export const setVerbosity = (level: Verbosity) => coreLogger.setVerbosity(level);
 export const addHandler = (handler: ILogHandler) => coreLogger.addHandler(handler);
 

package/src/example.ts

@@ -10,7 +10,7 @@ import logger, {
     error,
     success,
     critical,
-    createScopedLogger,
+    scope,
     setGlobalPrefix,
     setVerbosity,
     setTheme,
@@ -151,9 +151,9 @@ export function demonstrateTiming() {
 }
 
 export function demonstrateScopedLogger() {
-    const apiLogger = createScopedLogger('API');
-    const dbLogger = createScopedLogger('DB');
-    const authLogger = createScopedLogger('AUTH');
+    const apiLogger = scope('API');
+    const dbLogger = scope('DB');
+    const authLogger = scope('AUTH');
     
     apiLogger.info('🌐 Fetching user data', { endpoint: '/api/users' });
     dbLogger.debug('💾 Database query executed', { query: 'SELECT * FROM users LIMIT 10' });

package/src/exports-module.ts

@@ -280,7 +280,7 @@ export const groupEnd = () => exportLogger.groupEnd();
 export const time = (label: string) => exportLogger.time(label);
 export const timeEnd = (label: string) => exportLogger.timeEnd(label);
 export const setGlobalPrefix = (prefix: string) => exportLogger.setGlobalPrefix(prefix);
-export const createScopedLogger = (prefix: string) => exportLogger.createScopedLogger(prefix);
+export const scope = (prefix: string) => exportLogger.scope(prefix);
 export const setVerbosity = (level: Verbosity) => exportLogger.setVerbosity(level);
 export const addHandler = (handler: ILogHandler) => exportLogger.addHandler(handler);
 

package/src/handlers/ExportLogHandler.ts

@@ -465,4 +465,145 @@ export class ExportLogHandler implements ILogHandler {
     getAllLogs(): LogEntry[] {
         return [...this.buffer];
     }
+
+    /**
+     * Save export to file with download prompt
+     */
+    async saveToFile(format: ExportFormat, filters: ExportFilters = {}, options: ExportOptions = {}): Promise<boolean> {
+        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
+     */
+    private getMimeType(format: ExportFormat): string {
+        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
+     */
+    private generateFilename(format: ExportFormat, filters: ExportFilters): string {
+        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: string, filters: ExportFilters = {}, options: { 
+        apiKey?: string; 
+        batchSize?: number; 
+        format?: ExportFormat 
+    } = {}): Promise<boolean> {
+        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: Record<string, string> = {
+                    '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: ExportFormat, filters: ExportFilters = {}, options: ExportOptions = {}): ExportResult {
+        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
+                }
+            } as any
+        };
+    }
+
+    /**
+     * Estimate memory usage of buffer
+     */
+    private estimateMemoryUsage(): number {
+        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/src/handlers/FileLogHandler.ts

@@ -3,28 +3,167 @@
  */
 
 import type { ILogHandler, LogLevel, LogMetadata } from '../types/index.js';
+import { isNode, isBrowser } from '../utils/environment.js';
+import { safeSerialize } from '../utils/formatting.js';
 
 /**
- * File-based log handler for persistent logging
+ * 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') {
+    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 = {
-            filename: this.filename,
             timestamp: metadata.timestamp,
             level: level.toUpperCase(),
             prefix: metadata.prefix,
             message,
-            args: args.slice(1),
+            args: args.slice(1).map(arg => safeSerialize(arg)),
             location: metadata.stackInfo,
         };
 
-        console.debug('File log entry:', logEntry);
+        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/index.ts

@@ -53,7 +53,7 @@ export const groupEnd = () => logger.groupEnd();
 export const time = (label: string) => logger.time(label);
 export const timeEnd = (label: string) => logger.timeEnd(label);
 export const setGlobalPrefix = (prefix: string) => logger.setGlobalPrefix(prefix);
-export const createScopedLogger = (prefix: string) => logger.createScopedLogger(prefix);
+export const scope = (prefix: string) => logger.scope(prefix);
 export const setVerbosity = (level: Verbosity) => logger.setVerbosity(level);
 export const addHandler = (handler: ILogHandler) => logger.addHandler(handler);
 export const setTheme = (theme: ThemeVariant) => logger.setTheme(theme);

package/src/main.ts

@@ -11,7 +11,7 @@ import {
   time,
   timeEnd,
   trace,
-  createScopedLogger,
+  scope,
   cli,
   setTheme,
   setBannerType,
@@ -87,9 +87,9 @@ function testTiming() {
 
 function testScopedLogger() {
   info("Demonstrating scoped loggers...");
-  const apiLogger = createScopedLogger("API");
+  const apiLogger = scope("API");
   apiLogger.info("Fetching user data...");
-  const uiLogger = createScopedLogger("UI");
+  const uiLogger = scope("UI");
   uiLogger.debug("Rendering user profile component.");
   apiLogger.success("User data fetched successfully.");
   apiLogger.error("Failed to update settings.");