@tamyla/clodo-framework 3.1.4 → 3.1.8

package/bin/shared/database/orchestrator.js

@@ -13,6 +13,7 @@ import { existsSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { promisify } from 'util';
+import { logger } from '../logging/Logger.js';
 
 const execAsync = promisify(exec);
 
@@ -186,7 +187,7 @@ export class DatabaseOrchestrator {
           console.log(`✅ ${env} environment completed successfully`);
 
         } catch (error) {
-          console.error(`❌ ${env} environment failed: ${error.message}`);
+          logger.error(`${env} environment failed`, { error: error.message });
           
           results.environments[env] = {
             status: 'failed',
@@ -261,7 +262,7 @@ export class DatabaseOrchestrator {
           results.migrationsApplied += dbResult.migrationsApplied || 0;
           
         } catch (error) {
-          console.error(`   ❌ Database ${dbConfig.name} migration failed: ${error.message}`);
+          logger.error(`Database ${dbConfig.name} migration failed`, { error: error.message });
           results.databases[dbConfig.name] = {
             status: 'failed',
             error: error.message
@@ -522,7 +523,7 @@ export class DatabaseOrchestrator {
             );
             cleanupResults.operations[dbConfig.name] = cleanupResult;
           } catch (error) {
-            console.error(`❌ Cleanup failed for ${dbConfig.name}: ${error.message}`);
+            logger.error(`Cleanup failed for ${dbConfig.name}`, { error: error.message });
             cleanupResults.operations[dbConfig.name] = {
               status: 'failed',
               error: error.message
@@ -718,7 +719,7 @@ export class DatabaseOrchestrator {
         writeFile(this.backupPaths.audit, logLine);
       }
     } catch (error) {
-      console.warn(`⚠️ Failed to log audit event: ${error.message}`);
+      logger.warn('Failed to log audit event', { error: error.message });
     }
   }
 }

package/bin/shared/deployment/auditor.js

@@ -19,6 +19,7 @@
 import { existsSync, writeFileSync, appendFileSync, mkdirSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join, dirname } from 'path';
 import { execSync } from 'child_process';
+import { logger } from '../logging/Logger.js';
 
 export class DeploymentAuditor {
   constructor(options = {}) {
@@ -253,7 +254,7 @@ export class DeploymentAuditor {
     const deployment = this.currentSession.deployments.get(deploymentId);
     
     if (!deployment) {
-      console.warn(`⚠️  Deployment not found for phase logging: ${deploymentId}`);
+      logger.warn('Deployment not found for phase logging', { deploymentId });
       return;
     }
 
@@ -319,7 +320,7 @@ export class DeploymentAuditor {
       context
     });
 
-    console.error(`❌ Deployment error logged: ${deploymentId}`);
+    logger.error('Deployment error logged', { deploymentId });
   }
 
   /**
@@ -519,7 +520,7 @@ export class DeploymentAuditor {
       }
 
     } catch (error) {
-      console.error(`⚠️  Failed to write audit log: ${error.message}`);
+      logger.error('Failed to write audit log', { error: error.message });
     }
   }
 
@@ -542,7 +543,7 @@ export class DeploymentAuditor {
       });
 
     } catch (error) {
-      console.error(`⚠️  Failed to rotate log file: ${error.message}`);
+      logger.error('Failed to rotate log file', { error: error.message });
     }
   }
 
@@ -555,7 +556,7 @@ export class DeploymentAuditor {
     const deployment = this.currentSession.deployments.get(deploymentId);
     
     if (!deployment) {
-      console.warn(`⚠️  Cannot generate report: deployment ${deploymentId} not found`);
+      logger.warn('Cannot generate report: deployment not found', { deploymentId });
       return null;
     }
 
@@ -808,7 +809,7 @@ export class DeploymentAuditor {
    */
   async sendSecurityAlert(securityEvent) {
     if (!this.config.alertWebhook) {
-      console.warn('⚠️  Security alert webhook not configured');
+      logger.warn('Security alert webhook not configured');
       return;
     }
 
@@ -830,7 +831,7 @@ export class DeploymentAuditor {
       });
 
     } catch (error) {
-      console.error(`❌ Failed to send security alert: ${error.message}`);
+      logger.error('Failed to send security alert', { error: error.message });
     }
   }
 
@@ -896,7 +897,7 @@ export class DeploymentAuditor {
       console.log(`🧹 Audit cleanup completed: ${cleanupResults.filesRemoved} files removed`);
 
     } catch (error) {
-      console.error(`❌ Audit cleanup failed: ${error.message}`);
+      logger.error('Audit cleanup failed', { error: error.message });
       cleanupResults.errors.push({ general: error.message });
     }
 

package/bin/shared/logging/Logger.js

@@ -0,0 +1,214 @@
+/**
+ * Unified Logger for Clodo Framework
+ * Replaces: 6 separate logging implementations
+ * Savings: 300+ lines, unified logging across entire codebase
+ * 
+ * @version 1.0.0
+ */
+
+import { appendFileSync, mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+
+const LOG_LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  FATAL: 4
+};
+
+export class Logger {
+  constructor(context = {}) {
+    this.context = context;
+    this.logLevel = this._parseLogLevel(process.env.LOG_LEVEL || 'info');
+    this.logDir = process.env.LOG_DIR || null;
+    this.logFile = null;
+    this.cache = new Map();
+    this.isDev = process.env.NODE_ENV !== 'production';
+    
+    if (this.logDir) {
+      mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+
+  /**
+   * DEBUG level logging
+   */
+  debug(message, data = {}) {
+    if (this.logLevel > LOG_LEVELS.DEBUG) return;
+    this._log('DEBUG', message, data);
+  }
+
+  /**
+   * INFO level logging
+   */
+  info(message, data = {}) {
+    if (this.logLevel > LOG_LEVELS.INFO) return;
+    this._log('INFO', message, data);
+  }
+
+  /**
+   * WARN level logging
+   */
+  warn(message, data = {}) {
+    if (this.logLevel > LOG_LEVELS.WARN) return;
+    this._log('WARN', message, data);
+  }
+
+  /**
+   * ERROR level logging
+   */
+  error(message, data = {}) {
+    if (this.logLevel > LOG_LEVELS.ERROR) return;
+    this._log('ERROR', message, data);
+  }
+
+  /**
+   * FATAL level logging (exits process)
+   */
+  fatal(message, data = {}) {
+    this._log('FATAL', message, data);
+    if (!this.isDev) {
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Log HTTP request
+   */
+  logRequest(request, context = {}) {
+    this.info('HTTP Request', {
+      method: request.method,
+      url: request.url,
+      userAgent: request.headers?.get?.('User-Agent'),
+      ...context
+    });
+  }
+
+  /**
+   * Log deployment event
+   */
+  logDeployment(deploymentId, message, context = {}) {
+    this.info(`[Deployment ${deploymentId}] ${message}`, {
+      deploymentId,
+      ...context
+    });
+  }
+
+  /**
+   * Log audit event
+   */
+  logAudit(eventType, domain, details = {}) {
+    this.info(`[Audit] ${eventType} for ${domain}`, {
+      eventType,
+      domain,
+      ...details
+    });
+  }
+
+  /**
+   * Log performance metric
+   */
+  logPerformance(operation, durationMs, context = {}) {
+    const level = durationMs > 5000 ? 'warn' : 'info';
+    this[level](`Performance: ${operation}`, {
+      operation,
+      durationMs,
+      ...context
+    });
+  }
+
+  /**
+   * Redact sensitive information from text
+   */
+  redact(text) {
+    if (typeof text !== 'string') return text;
+    
+    const patterns = [
+      // Cloudflare tokens
+      [/(CLOUDFLARE_API_TOKEN=?)(\w{20,})/gi, '$1[REDACTED]'],
+      // Generic tokens
+      [/(token|api[_-]?key|auth[_-]?token)["']?[:=]\s*["']?([a-zA-Z0-9_-]{20,})["']?/gi, '$1: [REDACTED]'],
+      // Passwords
+      [/(password|passwd|pwd)["']?[:=]\s*["']?([^"'\s]{3,})["']?/gi, '$1: [REDACTED]'],
+      // Secrets
+      [/(secret|key)["']?[:=]\s*["']?([a-zA-Z0-9_-]{10,})["']?/gi, '$1: [REDACTED]'],
+      // Account/Zone IDs (partial)
+      [/(account[_-]?id|zone[_-]?id)["']?[:=]\s*["']?([a-zA-Z0-9]{8})([a-zA-Z0-9]{24,})["']?/gi, '$1: $2[REDACTED]']
+    ];
+    
+    let redacted = text;
+    patterns.forEach(([pattern, replacement]) => {
+      redacted = redacted.replace(pattern, replacement);
+    });
+    return redacted;
+  }
+
+  /**
+   * Set log file for file output
+   */
+  setLogFile(filePath) {
+    this.logFile = filePath;
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  /**
+   * Private: Core logging implementation
+   */
+  _log(level, message, data = {}) {
+    const timestamp = new Date().toISOString();
+    const contextStr = Object.keys(this.context).length > 0 
+      ? ` [${JSON.stringify(this.context)}]`
+      : '';
+    
+    const logMessage = `[${timestamp}] ${level}${contextStr}: ${message}`;
+    const redactedMessage = this.redact(logMessage);
+    
+    // Console output
+    const display = data && Object.keys(data).length > 0
+      ? `${redactedMessage} ${this.redact(JSON.stringify(data))}`
+      : redactedMessage;
+    
+    console.log(display);
+    
+    // File output
+    if (this.logFile) {
+      try {
+        const fileEntry = JSON.stringify({
+          timestamp,
+          level,
+          message: this.redact(message),
+          context: this.context,
+          data: this.redact(JSON.stringify(data))
+        }) + '\n';
+        
+        appendFileSync(this.logFile, fileEntry);
+      } catch (error) {
+        console.error('Failed to write to log file:', error.message);
+      }
+    }
+  }
+
+  /**
+   * Parse log level string to numeric value
+   */
+  _parseLogLevel(levelStr) {
+    const upper = levelStr.toUpperCase();
+    return LOG_LEVELS[upper] ?? LOG_LEVELS.INFO;
+  }
+}
+
+/**
+ * Export singleton logger
+ */
+export const logger = new Logger({ framework: 'clodo' });
+
+/**
+ * Backwards compatible factory function (for gradual migration)
+ */
+export const createLogger = (prefix = 'ClodoFramework') => {
+  return new Logger({ prefix });
+};

package/bin/shared/monitoring/production-monitor.js

@@ -5,6 +5,7 @@
 
 import { writeFile, appendFile, mkdir } from 'fs/promises';
 import { join } from 'path';
+import { logger } from '../logging/Logger.js';
 
 export class ProductionMonitor {
   constructor(options = {}) {
@@ -104,18 +105,29 @@ export class ProductionMonitor {
       }
     };
 
-    // Console output for development
-    const consoleMethod = level === 'error' || level === 'fatal' ? 'error' :
-                         level === 'warn' ? 'warn' : 'log';
-    console[consoleMethod](`[${level.toUpperCase()}] ${message}`, data);
+    // Use Logger for output
+    const methodMap = {
+      debug: 'debug',
+      info: 'info',
+      warn: 'warn',
+      error: 'error',
+      fatal: 'fatal'
+    };
+    
+    const logMethod = methodMap[level] || 'info';
+    logger[logMethod](message, data);
 
-    // File logging
+    // File logging through Logger
+    if (!this.config.logDir) {
+      this.config.logDir = 'logs';
+    }
     try {
       const logFile = join(this.config.logDir, `${new Date().toISOString().split('T')[0]}.log`);
-      const logLine = JSON.stringify(logEntry) + '\n';
-      await appendFile(logFile, logLine);
+      if (!logger.logFile) {
+        logger.setLogFile(logFile);
+      }
     } catch (error) {
-      console.error('Failed to write log file:', error);
+      logger.error('Failed to set up log file', { error: error.message });
     }
 
     // Track errors for metrics
@@ -354,7 +366,7 @@ export class ProductionMonitor {
       const metricsData = this.getDetailedMetrics();
       await writeFile(metricsFile, JSON.stringify(metricsData, null, 2));
     } catch (error) {
-      console.error('Failed to save metrics:', error);
+      logger.error('Failed to save metrics', { error: error.message });
     }
   }