@mks2508/better-logger 0.0.2-alpha.2 → 0.8.1-alpha.1

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/styling-themes.js

@@ -0,0 +1,207 @@
+/**
+ * Styling and Themes Example
+ * 
+ * Demonstrates visual styling capabilities including:
+ * - Theme switching and customization
+ * - Custom style creation with StyleBuilder
+ * - Banner display variations
+ * - SVG background integration
+ * - Pre-built style presets
+ * 
+ * Run: node examples/styling-themes.js
+ * Note: Best viewed in browser console for full visual effects
+ */
+
+import { Logger } from '@mks2508/better-logger';
+import { 
+  setTheme, 
+  showBanner, 
+  createStyle, 
+  stylePresets,
+  logAnimated,
+  logWithSVG 
+} from '@mks2508/better-logger/styling';
+
+console.log('🎨 Better Logger - Styling and Themes Example\n');
+
+const logger = new Logger({ prefix: 'STYLE' });
+
+// Theme demonstration
+console.log('🌈 Testing different themes:');
+
+const themes = ['default', 'dark', 'neon', 'cyberpunk', 'retro'];
+
+for (const theme of themes) {
+  setTheme(theme);
+  logger.info(`Theme changed to: ${theme}`);
+  
+  // Show some logs in this theme
+  logger.success(`${theme} theme is active!`);
+  logger.warn(`Warning message in ${theme} theme`);
+  logger.error(`Error message in ${theme} theme`);
+  
+  console.log(''); // Add spacing
+}
+
+// Banner demonstrations
+console.log('\n🎭 Testing different banner types:');
+
+const bannerTypes = ['simple', 'ascii', 'unicode', 'svg', 'animated'];
+
+bannerTypes.forEach((type, index) => {
+  setTimeout(() => {
+    console.log(`\n--- ${type.toUpperCase()} BANNER ---`);
+    showBanner(type);
+    logger.info(`Showing ${type} banner style`);
+  }, index * 1000);
+});
+
+// Wait for banners, then continue
+setTimeout(() => {
+  console.log('\n✨ Testing custom style creation:');
+
+  // Create custom styles using StyleBuilder
+  const headerStyle = createStyle()
+    .bg('linear-gradient(135deg, #667eea, #764ba2)')
+    .color('white')
+    .padding('12px 24px')
+    .rounded('8px')
+    .bold()
+    .shadow('0 4px 15px rgba(102, 126, 234, 0.3)')
+    .build();
+
+  const alertStyle = createStyle()
+    .bg('linear-gradient(45deg, #ff6b6b, #feca57)')
+    .color('#333')
+    .padding('10px 20px')
+    .border('2px solid #ff5252')
+    .rounded('25px')
+    .bold()
+    .animation('pulse 1s ease-in-out infinite')
+    .build();
+
+  const codeStyle = createStyle()
+    .backgroundColor('#2c3e50')
+    .color('#ecf0f1')
+    .padding('8px 12px')
+    .font('Monaco, Consolas, monospace')
+    .border('1px solid #34495e')
+    .rounded('4px')
+    .build();
+
+  console.log('%cCustom Header Style', headerStyle);
+  console.log('%cCustom Alert Style', alertStyle);
+  console.log('%cCustom Code Style', codeStyle);
+
+  // Using pre-built style presets
+  console.log('\n🎯 Testing style presets:');
+
+  console.log('%c✅ Success Preset', stylePresets.success);
+  console.log('%c❌ Error Preset', stylePresets.error);
+  console.log('%c⚠️ Warning Preset', stylePresets.warning);
+  console.log('%cℹ️ Info Preset', stylePresets.info);
+  console.log('%c🎯 Accent Preset', stylePresets.accent);
+
+  // Advanced styling combinations
+  console.log('\n🔧 Advanced styling combinations:');
+
+  const gradientButton = createStyle()
+    .bg('linear-gradient(45deg, #667eea, #764ba2, #f093fb, #f5576c)')
+    .color('white')
+    .padding('15px 30px')
+    .rounded('50px')
+    .bold()
+    .shadow('0 8px 25px rgba(102, 126, 234, 0.4)')
+    .animation('backgroundMove 3s ease infinite')
+    .css('background-size', '400% 400%')
+    .build();
+
+  console.log('%c🚀 Gradient Button Style', gradientButton);
+
+  const glassMorphism = createStyle()
+    .bg('rgba(255, 255, 255, 0.1)')
+    .color('#333')
+    .padding('20px')
+    .rounded('15px')
+    .border('1px solid rgba(255, 255, 255, 0.2)')
+    .css('backdrop-filter', 'blur(10px)')
+    .shadow('0 8px 32px rgba(0, 0, 0, 0.1)')
+    .build();
+
+  console.log('%c🪟 Glass Morphism Style', glassMorphism);
+
+  // SVG background demonstration (works in browser)
+  if (typeof document !== 'undefined') {
+    console.log('\n🖼️ Testing SVG backgrounds:');
+
+    const brandSVG = `
+      <svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 400 80'>
+        <defs>
+          <linearGradient id='brandGrad' x1='0%' y1='0%' x2='100%' y2='0%'>
+            <stop offset='0%' style='stop-color:#667eea'/>
+            <stop offset='100%' style='stop-color:#764ba2'/>
+          </linearGradient>
+        </defs>
+        <rect width='100%' height='100%' fill='url(#brandGrad)' rx='8'/>
+        <text x='200' y='45' text-anchor='middle' fill='white' 
+              font-family='Arial' font-size='18' font-weight='bold'>
+          BETTER LOGGER
+        </text>
+      </svg>
+    `;
+
+    logWithSVG('Custom SVG Background!', brandSVG, {
+      width: 400,
+      height: 80,
+      padding: '40px 200px'
+    });
+
+    // Animated logging (browser only)
+    console.log('\n✨ Testing animated logging:');
+    
+    logAnimated('🌟 This message has animated gradients!', 3);
+    
+    setTimeout(() => {
+      logAnimated('🎉 Animation completed!', 2);
+    }, 3500);
+  }
+
+  // Style combinations for different contexts
+  console.log('\n📱 Context-specific styling:');
+
+  const mobileStyle = createStyle()
+    .bg('#007AFF')
+    .color('white')
+    .padding('8px 16px')
+    .rounded('18px')
+    .fontSize('14px')
+    .build();
+
+  const desktopStyle = createStyle()
+    .bg('linear-gradient(135deg, #74b9ff, #0984e3)')
+    .color('white')
+    .padding('12px 24px')
+    .rounded('8px')
+    .fontSize('16px')
+    .shadow('0 4px 12px rgba(116, 185, 255, 0.3)')
+    .build();
+
+  const terminalStyle = createStyle()
+    .backgroundColor('#1e1e1e')
+    .color('#00ff00')
+    .padding('6px 12px')
+    .font('Fira Code, Monaco, monospace')
+    .border('1px solid #333')
+    .build();
+
+  console.log('%c📱 Mobile Style', mobileStyle);
+  console.log('%c🖥️ Desktop Style', desktopStyle);
+  console.log('%c💻 Terminal Style', terminalStyle);
+
+  console.log('\n✅ Styling and themes examples completed!');
+  
+  // Reset to default theme
+  setTheme('default');
+  logger.info('Theme reset to default');
+
+}, 6000); // Wait for banner demonstrations