conception-assistant/utils/logger.js

/**
 * Centralized logging system for Conception Assistant
 * Provides structured logging for all application events
 */

const LOG_LEVELS = {
  ERROR: 'ERROR',
  WARN: 'WARN',
  INFO: 'INFO',
  DEBUG: 'DEBUG'
};

const LOG_CATEGORIES = {
  API: 'API',
  AI: 'AI',
  UI: 'UI',
  STORAGE: 'STORAGE',
  EXPORT: 'EXPORT',
  AUTH: 'AUTH',
  SYSTEM: 'SYSTEM'
};

class Logger {
  constructor() {
    this.enabled = process.env.LOGGING_ENABLED !== 'false';
    this.logLevel = process.env.LOG_LEVEL || 'INFO';
  }

  log(level, category, message, metadata = {}) {
    if (!this.enabled) return;

    const timestamp = new Date().toISOString();
    const logEntry = {
      timestamp,
      level,
      category,
      message,
      ...metadata
    };

    const formattedMessage = `[${timestamp}] [${level}] [${category}] ${message}`;

    switch (level) {
      case LOG_LEVELS.ERROR:
        console.error(formattedMessage, metadata);
        break;
      case LOG_LEVELS.WARN:
        console.warn(formattedMessage, metadata);
        break;
      case LOG_LEVELS.INFO:
        console.info(formattedMessage, metadata);
        break;
      case LOG_LEVELS.DEBUG:
        console.log(formattedMessage, metadata);
        break;
      default:
        console.log(formattedMessage, metadata);
    }

    return logEntry;
  }

  // API Request logging
  apiRequest(method, endpoint, payload = {}) {
    return this.log(LOG_LEVELS.INFO, LOG_CATEGORIES.API, `${method} ${endpoint}`, {
      method,
      endpoint,
      payloadSize: JSON.stringify(payload).length
    });
  }

  apiResponse(endpoint, statusCode, duration) {
    return this.log(LOG_LEVELS.INFO, LOG_CATEGORIES.API, `Response ${endpoint}`, {
      endpoint,
      statusCode,
      duration: `${duration}ms`
    });
  }

  apiError(endpoint, error) {
    return this.log(LOG_LEVELS.ERROR, LOG_CATEGORIES.API, `API Error ${endpoint}`, {
      endpoint,
      error: error.message,
      stack: error.stack
    });
  }

  // AI Operations logging
  aiRequest(operation, model, tokens = 0) {
    return this.log(LOG_LEVELS.INFO, LOG_CATEGORIES.AI, `AI Request: ${operation}`, {
      operation,
      model,
      tokens
    });
  }

  aiResponse(operation, success, duration) {
    return this.log(LOG_LEVELS.INFO, LOG_CATEGORIES.AI, `AI Response: ${operation}`, {
      operation,
      success,
      duration: `${duration}ms`
    });
  }

  aiError(operation, error) {
    return this.log(LOG_LEVELS.ERROR, LOG_CATEGORIES.AI, `AI Error: ${operation}`, {
      operation,
      error: error.message
    });
  }

  // UI Events logging
  uiEvent(action, component, details = {}) {
    return this.log(LOG_LEVELS.DEBUG, LOG_CATEGORIES.UI, `UI Event: ${action}`, {
      action,
      component,
      ...details
    });
  }

  // Storage operations
  storageWrite(operation, journalId) {
    return this.log(LOG_LEVELS.INFO, LOG_CATEGORIES.STORAGE, `Storage Write: ${operation}`, {
      operation,
      journalId
    });
  }

  storageRead(operation, journalId) {
    return this.log(LOG_LEVELS.INFO, LOG_CATEGORIES.STORAGE, `Storage Read: ${operation}`, {
      operation,
      journalId
    });
  }

  storageError(operation, error) {
    return this.log(LOG_LEVELS.ERROR, LOG_CATEGORIES.STORAGE, `Storage Error: ${operation}`, {
      operation,
      error: error.message
    });
  }

  // Export operations
  exportOperation(type, format, size) {
    return this.log(LOG_LEVELS.INFO, LOG_CATEGORIES.EXPORT, `Export: ${type}`, {
      type,
      format,
      size: `${size} bytes`
    });
  }

  // System events
  systemStart(port) {
    return this.log(LOG_LEVELS.INFO, LOG_CATEGORIES.SYSTEM, 'Application started', {
      port,
      nodeVersion: process.version,
      platform: process.platform
    });
  }

  systemError(message, error) {
    return this.log(LOG_LEVELS.ERROR, LOG_CATEGORIES.SYSTEM, message, {
      error: error.message,
      stack: error.stack
    });
  }

  // Generic logging methods
  error(category, message, metadata = {}) {
    return this.log(LOG_LEVELS.ERROR, category, message, metadata);
  }

  warn(category, message, metadata = {}) {
    return this.log(LOG_LEVELS.WARN, category, message, metadata);
  }

  info(category, message, metadata = {}) {
    return this.log(LOG_LEVELS.INFO, category, message, metadata);
  }

  debug(category, message, metadata = {}) {
    return this.log(LOG_LEVELS.DEBUG, category, message, metadata);
  }
}

// Export singleton instance
const logger = new Logger();

module.exports = {
  logger,
  LOG_LEVELS,
  LOG_CATEGORIES
};