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

package/examples/basic-logging.js

@@ -0,0 +1,75 @@
+/**
+ * Basic Logging Example
+ * 
+ * Demonstrates fundamental logging capabilities including:
+ * - Different log levels (debug, info, warn, error, critical)
+ * - Message formatting with additional arguments
+ * - Success logging for positive outcomes
+ * 
+ * Run: node examples/basic-logging.js
+ */
+
+import { Logger } from '@mks2508/better-logger';
+
+console.log('🚀 Better Logger - Basic Logging Example\n');
+
+// Create a new logger instance
+const logger = new Logger({
+  prefix: 'BASIC',
+  level: 'debug'  // Show all log levels
+});
+
+// Basic logging methods demonstration
+console.log('📝 Testing different log levels:');
+
+logger.debug('This is a debug message with data:', { debugInfo: true, value: 42 });
+
+logger.info('Application started successfully', { 
+  version: '1.0.0', 
+  environment: 'development' 
+});
+
+logger.warn('Memory usage is high', { 
+  usage: '85%', 
+  threshold: '80%',
+  recommendation: 'Consider optimizing memory usage'
+});
+
+logger.error('Failed to connect to database', {
+  host: 'localhost',
+  port: 5432,
+  error: 'ECONNREFUSED',
+  retryAttempt: 3
+});
+
+logger.critical('System is out of disk space', {
+  available: '100MB',
+  required: '2GB',
+  action: 'immediate_attention_required'
+});
+
+logger.success('User authentication completed', {
+  userId: 'user_123',
+  method: 'oauth2',
+  timestamp: new Date().toISOString()
+});
+
+// Demonstrate logging with different data types
+console.log('\n📊 Testing different data types:');
+
+logger.info('String message');
+logger.info('Number value:', 42);
+logger.info('Boolean value:', true);
+logger.info('Array data:', [1, 2, 3, 'hello']);
+logger.info('Object data:', { name: 'John', age: 30, active: true });
+logger.info('Multiple arguments:', 'user', 'action', { result: 'success' }, 123);
+
+// Error object logging
+console.log('\n❌ Testing error object logging:');
+try {
+  throw new Error('Something went wrong!');
+} catch (error) {
+  logger.error('Caught an error:', error);
+}
+
+console.log('\n✅ Basic logging examples completed!');

package/examples/data-export.js

@@ -0,0 +1,234 @@
+/**
+ * Data Export and Remote Logging Example
+ * 
+ * Demonstrates export and remote logging capabilities including:
+ * - Log buffering and management
+ * - Exporting logs in different formats (CSV, JSON, XML)
+ * - Remote logging to external services
+ * - Log filtering and analytics
+ * - Buffer statistics and management
+ * 
+ * Run: node examples/data-export.js
+ */
+
+import { ExportLogger } from '@mks2508/better-logger/exports';
+import fs from 'fs';
+import path from 'path';
+
+console.log('📤 Better Logger - Data Export Example\n');
+
+// Create ExportLogger with buffering enabled
+const logger = new ExportLogger({
+  bufferSize: 100,
+  bufferMode: 'circular',
+  prefix: 'EXPORT'
+});
+
+// Generate sample log data
+console.log('📝 Generating sample log data:');
+
+const sampleData = [
+  { level: 'info', message: 'User login successful', data: { userId: 'user_123', ip: '192.168.1.100' } },
+  { level: 'warn', message: 'High memory usage detected', data: { usage: '85%', threshold: '80%' } },
+  { level: 'error', message: 'Database connection timeout', data: { host: 'db.example.com', timeout: 5000 } },
+  { level: 'info', message: 'API request processed', data: { endpoint: '/api/users', method: 'GET', duration: 245 } },
+  { level: 'critical', message: 'Disk space critically low', data: { available: '100MB', required: '2GB' } },
+  { level: 'success', message: 'Backup completed successfully', data: { size: '2.3GB', duration: '5 minutes' } },
+  { level: 'debug', message: 'Debug trace for user session', data: { sessionId: 'sess_789', debug: true } },
+  { level: 'error', message: 'Payment processing failed', data: { orderId: 'ORD-456', error: 'CARD_DECLINED' } },
+  { level: 'info', message: 'Cache invalidation completed', data: { keys: ['user:123', 'session:789'], count: 2 } },
+  { level: 'warn', message: 'Rate limit approaching', data: { current: 95, limit: 100, window: '1 minute' } }
+];
+
+// Log all sample data
+sampleData.forEach((item, index) => {
+  const logMethod = logger[item.level] || logger.info;
+  logMethod.call(logger, `Sample ${index + 1}: ${item.message}`, item.data);
+});
+
+console.log(`\n📊 Generated ${sampleData.length} log entries`);
+
+// Show buffer statistics
+const bufferStats = logger.getBufferStats();
+console.log('\n📈 Buffer Statistics:');
+console.log(`- Total entries: ${bufferStats.totalEntries}`);
+console.log(`- Buffer usage: ${bufferStats.usage}%`);
+console.log(`- Oldest entry: ${bufferStats.oldestEntry?.timestamp || 'N/A'}`);
+console.log(`- Newest entry: ${bufferStats.newestEntry?.timestamp || 'N/A'}`);
+
+// Show log statistics by level
+const logStats = logger.getLogStats();
+console.log('\n📋 Log Level Statistics:');
+Object.entries(logStats).forEach(([level, count]) => {
+  if (typeof count === 'number' && count > 0) {
+    console.log(`- ${level.toUpperCase()}: ${count} entries`);
+  }
+});
+
+// Export logs in different formats
+console.log('\n📄 Exporting logs in different formats:');
+
+try {
+  // Create exports directory if it doesn't exist
+  const exportsDir = path.join(process.cwd(), 'exports');
+  if (!fs.existsSync(exportsDir)) {
+    fs.mkdirSync(exportsDir, { recursive: true });
+  }
+
+  // Export all logs as CSV
+  console.log('🔄 Exporting as CSV...');
+  const csvData = await logger.exportLogs('csv');
+  fs.writeFileSync(path.join(exportsDir, 'logs-all.csv'), csvData);
+  console.log('✅ CSV export saved to: exports/logs-all.csv');
+
+  // Export error logs as JSON
+  console.log('🔄 Exporting errors as JSON...');
+  const jsonErrorData = await logger.exportLogs('json', {
+    filter: { level: ['error', 'critical'] },
+    includeStackTrace: true
+  });
+  fs.writeFileSync(path.join(exportsDir, 'logs-errors.json'), jsonErrorData);
+  console.log('✅ JSON export (errors only) saved to: exports/logs-errors.json');
+
+  // Export recent logs as XML
+  console.log('🔄 Exporting recent logs as XML...');
+  const xmlData = await logger.exportLogs('xml', {
+    limit: 5,
+    groupBy: 'level'
+  });
+  fs.writeFileSync(path.join(exportsDir, 'logs-recent.xml'), xmlData);
+  console.log('✅ XML export (recent 5) saved to: exports/logs-recent.xml');
+
+  // Export with date filtering
+  const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
+  console.log('🔄 Exporting last 24 hours as JSON...');
+  const recentJsonData = await logger.exportLogs('json', {
+    filter: { from: oneDayAgo },
+    groupBy: 'level'
+  });
+  fs.writeFileSync(path.join(exportsDir, 'logs-24h.json'), recentJsonData);
+  console.log('✅ JSON export (24h) saved to: exports/logs-24h.json');
+
+} catch (error) {
+  console.error('❌ Export error:', error.message);
+}
+
+// Demonstrate remote logging (simulation)
+console.log('\n📡 Remote Logging Simulation:');
+
+// Simulate HTTP endpoint
+const simulateHttpEndpoint = (data) => {
+  console.log('📤 HTTP POST to https://api.logs.example.com/collect');
+  console.log(`📊 Payload size: ${JSON.stringify(data).length} bytes`);
+  console.log(`📋 Entries: ${data.length}`);
+  return Promise.resolve({ status: 200, message: 'Logs received' });
+};
+
+// Simulate WebSocket endpoint
+const simulateWebSocketEndpoint = (data) => {
+  console.log('🔗 WebSocket send to wss://realtime.logs.example.com');
+  console.log(`📊 Message size: ${JSON.stringify(data).length} bytes`);
+  return Promise.resolve({ connected: true, delivered: true });
+};
+
+// Add remote handlers (simulation)
+logger.addRemoteHandler('https://api.logs.example.com/collect', {
+  apiKey: 'demo-key-123',
+  handler: simulateHttpEndpoint,
+  retries: 3,
+  batchSize: 5
+});
+
+logger.addRemoteHandler('wss://realtime.logs.example.com', {
+  handler: simulateWebSocketEndpoint,
+  immediate: true,
+  filter: (entry) => ['error', 'critical'].includes(entry.level)
+});
+
+// Simulate sending logs to remote endpoints
+console.log('🚀 Sending logs to remote endpoints...');
+
+// Get logs for remote transmission
+const logsForRemote = logger.getLogs({
+  limit: 3,
+  level: ['error', 'warn', 'critical']
+});
+
+console.log(`📨 Preparing to send ${logsForRemote.length} priority logs`);
+
+// Simulate batch sending
+for (let i = 0; i < logsForRemote.length; i += 2) {
+  const batch = logsForRemote.slice(i, i + 2);
+  
+  console.log(`\n📦 Batch ${Math.floor(i/2) + 1}:`);
+  await simulateHttpEndpoint(batch);
+  
+  // Simulate delay between batches
+  await new Promise(resolve => setTimeout(resolve, 100));
+}
+
+// Simulate real-time critical alerts
+console.log('\n🚨 Simulating critical alert...');
+logger.critical('System failure detected', {
+  service: 'payment-processor',
+  error: 'CONNECTION_LOST',
+  impact: 'high',
+  requiresImmediate: true
+});
+
+// Advanced analytics demonstration
+console.log('\n📈 Advanced Analytics:');
+
+const analytics = logger.getAnalytics({
+  timeframe: '1h',
+  groupBy: 'level',
+  includeMetrics: true
+});
+
+console.log('🔍 Analytics Summary:');
+console.log(`- Total logs analyzed: ${analytics.summary.totalLogs}`);
+console.log(`- Error rate: ${(analytics.summary.errorRate * 100).toFixed(2)}%`);
+console.log(`- Average per hour: ${analytics.summary.averagePerHour}`);
+
+console.log('\n📊 Level Distribution:');
+Object.entries(analytics.distribution).forEach(([level, count]) => {
+  const percentage = ((count / analytics.summary.totalLogs) * 100).toFixed(1);
+  console.log(`- ${level.toUpperCase()}: ${count} (${percentage}%)`);
+});
+
+// Log search and filtering
+console.log('\n🔍 Log Search and Filtering:');
+
+// Search by content
+const paymentLogs = logger.getLogs({
+  content: 'payment',
+  limit: 10
+});
+console.log(`Found ${paymentLogs.length} logs containing 'payment'`);
+
+// Filter by level and prefix
+const errorLogs = logger.getLogs({
+  level: ['error', 'critical'],
+  prefix: 'EXPORT'
+});
+console.log(`Found ${errorLogs.length} error/critical logs with EXPORT prefix`);
+
+// Memory management
+console.log('\n🧹 Buffer Management:');
+console.log(`Current buffer size: ${logger.getBufferStats().totalEntries} entries`);
+
+// Clear old logs (simulate retention policy)
+const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000);
+const clearedCount = logger.clearLogs({
+  before: oneHourAgo,
+  level: 'debug'  // Clear only debug logs older than 1 hour
+});
+console.log(`Cleared ${clearedCount} old debug logs`);
+
+// Final buffer stats
+const finalStats = logger.getBufferStats();
+console.log(`Buffer after cleanup: ${finalStats.totalEntries} entries`);
+
+console.log('\n✅ Data export and remote logging examples completed!');
+console.log('📁 Check the exports/ directory for generated files');
+console.log('🔍 Examine the exported files to see different format outputs');

package/examples/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "better-logger-examples",
+  "version": "1.0.0",
+  "description": "Examples for Better Logger package",
+  "type": "module",
+  "scripts": {
+    "basic": "node basic-logging.js",
+    "performance": "node performance-timing.js", 
+    "styling": "node styling-themes.js",
+    "export": "node data-export.js",
+    "all": "npm run basic && npm run performance && npm run styling && npm run export"
+  },
+  "dependencies": {
+    "@mks2508/better-logger": "^0.0.2-alpha.2"
+  }
+}

package/examples/performance-timing.js

@@ -0,0 +1,170 @@
+/**
+ * Performance Timing Example
+ * 
+ * Demonstrates performance monitoring capabilities including:
+ * - Basic timing operations with time() and timeEnd()
+ * - Intermediate timing with timeLog()
+ * - Nested timing operations
+ * - Performance comparison between operations
+ * 
+ * Run: node examples/performance-timing.js
+ */
+
+import { Logger } from '@mks2508/better-logger';
+
+console.log('⏱️ Better Logger - Performance Timing Example\n');
+
+// Create logger with performance tracking enabled
+const logger = new Logger({
+  prefix: 'PERF',
+  enablePerformance: true
+});
+
+// Simulate async operations
+const simulateWork = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const simulateHeavyWork = (ms) => {
+  const start = Date.now();
+  while (Date.now() - start < ms) {
+    // CPU intensive work
+    Math.random();
+  }
+};
+
+// Basic timing example
+console.log('🔄 Basic timing operations:');
+
+logger.time('basic-operation');
+await simulateWork(100);
+logger.timeEnd('basic-operation');
+
+// Multiple timers running simultaneously
+console.log('\n⚡ Concurrent operations:');
+
+logger.time('operation-1');
+logger.time('operation-2');
+logger.time('operation-3');
+
+await simulateWork(80);
+logger.timeEnd('operation-1');
+
+await simulateWork(50);
+logger.timeEnd('operation-2');
+
+await simulateWork(120);
+logger.timeEnd('operation-3');
+
+// Intermediate timing with timeLog
+console.log('\n📊 Step-by-step timing:');
+
+logger.time('multi-step-process');
+
+logger.info('Starting data processing...');
+await simulateWork(50);
+logger.timeLog('multi-step-process', 'Step 1: Data validation complete');
+
+logger.info('Processing records...');
+await simulateWork(80);
+logger.timeLog('multi-step-process', 'Step 2: Record processing complete');
+
+logger.info('Generating reports...');
+await simulateWork(60);
+logger.timeLog('multi-step-process', 'Step 3: Report generation complete');
+
+logger.info('Sending notifications...');
+await simulateWork(30);
+logger.timeEnd('multi-step-process');
+
+// Nested timing operations
+console.log('\n🔗 Nested timing operations:');
+
+logger.time('parent-operation');
+
+logger.info('Starting parent operation');
+
+  logger.time('child-operation-1');
+  await simulateWork(40);
+  logger.timeEnd('child-operation-1');
+
+  logger.time('child-operation-2');
+  await simulateWork(60);
+  logger.timeEnd('child-operation-2');
+
+  logger.time('child-operation-3');
+  await simulateWork(35);
+  logger.timeEnd('child-operation-3');
+
+logger.timeEnd('parent-operation');
+
+// Performance comparison
+console.log('\n🏃 Performance comparison:');
+
+// Method A: Array.push in loop
+logger.time('method-a-push');
+const arrayA = [];
+for (let i = 0; i < 10000; i++) {
+  arrayA.push(i);
+}
+logger.timeEnd('method-a-push');
+
+// Method B: Array.from
+logger.time('method-b-from');
+const arrayB = Array.from({ length: 10000 }, (_, i) => i);
+logger.timeEnd('method-b-from');
+
+// Method C: Spread operator
+logger.time('method-c-spread');
+const arrayC = [...Array(10000).keys()];
+logger.timeEnd('method-c-spread');
+
+// CPU vs I/O comparison
+console.log('\n🖥️ CPU vs I/O operations:');
+
+logger.time('cpu-intensive');
+simulateHeavyWork(50);  // Synchronous CPU work
+logger.timeEnd('cpu-intensive');
+
+logger.time('io-simulation');
+await simulateWork(50);  // Asynchronous I/O simulation
+logger.timeEnd('io-simulation');
+
+// Real-world scenario: Database simulation
+console.log('\n🗄️ Database operation simulation:');
+
+const simulateDatabaseQuery = async (query, delay) => {
+  const timerId = `db-query-${Math.random().toString(36).substr(2, 9)}`;
+  
+  logger.time(timerId);
+  logger.info(`Executing query: ${query}`);
+  
+  // Simulate network delay
+  await simulateWork(delay);
+  
+  logger.timeEnd(timerId);
+  
+  return { query, rows: Math.floor(Math.random() * 1000) };
+};
+
+// Simulate multiple database operations
+const queries = [
+  { query: 'SELECT * FROM users WHERE active = true', delay: 45 },
+  { query: 'SELECT COUNT(*) FROM orders WHERE date > NOW() - INTERVAL 30 DAY', delay: 120 },
+  { query: 'UPDATE users SET last_login = NOW() WHERE id = ?', delay: 25 },
+  { query: 'INSERT INTO audit_log (action, user_id, timestamp) VALUES (?, ?, ?)', delay: 15 }
+];
+
+logger.time('batch-database-operations');
+
+for (const { query, delay } of queries) {
+  const result = await simulateDatabaseQuery(query, delay);
+  logger.info(`Query result: ${result.rows} rows affected`);
+}
+
+logger.timeEnd('batch-database-operations');
+
+console.log('\n✅ Performance timing examples completed!');
+
+// Final timing statistics
+console.log('\n📈 Timing Statistics Summary:');
+logger.info('All timing operations have been logged above');
+logger.info('Each timer shows the exact duration in milliseconds');
+logger.info('Use these techniques to identify performance bottlenecks in your applications');

package/examples/simplified-api.js

@@ -0,0 +1,124 @@
+/**
+ * @fileoverview Examples of the new Simplified API for Advanced Logger
+ */
+
+import logger, { 
+    preset, 
+    hideTimestamp, 
+    showLocation, 
+    component, 
+    api, 
+    scope,
+    customize,
+    styles 
+} from '../dist/index.js';
+
+console.log('=== Advanced Logger - Simplified API Examples ===\n');
+
+// ===== BASIC USAGE - OUT-OF-THE-BOX =====
+console.log('1. Basic usage (no configuration needed):');
+logger.info('Application started');
+logger.success('Database connected');
+logger.warn('High memory usage detected');
+logger.error('Failed to load configuration');
+
+console.log('\n2. Available presets:');
+console.log('Available presets:', logger.presets());
+
+// ===== PRESET EXAMPLES =====
+console.log('\n3. Using presets:');
+
+console.log('\n   → Cyberpunk preset:');
+preset('cyberpunk');
+logger.info('System online');
+logger.critical('Security breach detected!');
+
+console.log('\n   → Minimal preset:');  
+preset('minimal');
+logger.info('Clean and simple logging');
+logger.success('Task completed successfully');
+
+console.log('\n   → Debug preset:');
+preset('debug');
+logger.debug('Detailed debugging info');
+logger.info('Processing data...');
+
+// Reset to default
+preset('default');
+
+// ===== TOGGLE EXAMPLES =====
+console.log('\n4. Toggle features:');
+
+console.log('\n   → Hide timestamp:');
+hideTimestamp();
+logger.info('No timestamp shown');
+
+console.log('\n   → Show location (with timestamp hidden):');
+showLocation();
+logger.info('Location info visible');
+
+// Reset for next examples
+logger.showTimestamp();
+
+// ===== SCOPED LOGGERS =====
+console.log('\n5. Scoped loggers:');
+
+console.log('\n   → Component logger:');
+const auth = component('UserAuth');
+auth.info('Login attempt');
+auth.success('User authenticated');
+auth.lifecycle('mount', 'Component mounted');
+auth.stateChange('idle', 'loading');
+
+console.log('\n   → API logger with badges:');
+const graphql = api('GraphQL').badges(['SLOW', 'CACHE']);
+graphql.info('Query executed');
+graphql.slow('Complex query', 2500);
+graphql.auth('Invalid token');
+
+console.log('\n   → Custom scoped logger:');
+const payment = scope('Payment').badges(['CRITICAL', 'AUDIT']);
+payment.info('Processing payment');
+payment.success('Payment completed');
+
+// ===== CONTEXT EXAMPLES =====
+console.log('\n6. Context logging:');
+const dbLogger = component('Database');
+
+dbLogger.context('Migration').run(() => {
+    dbLogger.info('Starting migration');
+    dbLogger.success('Tables created');
+    dbLogger.info('Migration completed');
+});
+// Context automatically removed after run()
+
+// ===== SIMPLE CUSTOMIZATION =====
+console.log('\n7. Simple customization:');
+customize({
+    message: { color: '#007bff', size: '15px' },
+    timestamp: { show: true },
+    location: { show: false }
+});
+
+logger.info('Customized message styling');
+logger.success('Custom color and size applied');
+
+// ===== ADVANCED STYLING (For power users) =====
+console.log('\n8. Advanced styling (power users):');
+
+styles()
+    .timestamp().muted().mono().compact()
+    .level().neon().uppercase()
+    .message().large().system()
+    .spacing('compact')
+    .apply();
+
+logger.info('Advanced custom styling applied');
+logger.warn('Neon level badges with large system font');
+
+console.log('\n=== Examples completed! ===');
+
+// Reset to clean state for any other examples
+preset('default');
+logger.showTimestamp();
+logger.showLocation();