Update utils/logging.py

utils/logging.py

@@ -1,234 +1,4 @@
 import logging
-import os
-import sys
-from datetime import datetime
-from typing import Optional, Dict, Any
-import json
-
-# Configure logging
-def setup_logger(name: str = "mona_app", level: str = "INFO") -> logging.Logger:
-    """
-    Set up a logger with both file and console handlers
-    """
-    logger = logging.getLogger(name)
-    
-    # Clear existing handlers to avoid duplicates
-    if logger.handlers:
-        logger.handlers.clear()
-    
-    # Set log level
-    log_level = getattr(logging, level.upper(), logging.INFO)
-    logger.setLevel(log_level)
-    
-    # Create formatters
-    detailed_formatter = logging.Formatter(
-        '%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s'
-    )
-    simple_formatter = logging.Formatter('%(levelname)s - %(message)s')
-    
-    # Console handler
-    console_handler = logging.StreamHandler(sys.stdout)
-    console_handler.setLevel(logging.INFO)
-    console_handler.setFormatter(simple_formatter)
-    
-    # File handler (if in a writable environment)
-    try:
-        log_dir = "/tmp/logs" if os.path.exists("/tmp") else "./logs"
-        os.makedirs(log_dir, exist_ok=True)
-        
-        log_file = os.path.join(log_dir, f"{name}.log")
-        file_handler = logging.FileHandler(log_file)
-        file_handler.setLevel(logging.DEBUG)
-        file_handler.setFormatter(detailed_formatter)
-        logger.addHandler(file_handler)
-    except Exception:
-        # If we can't create file handler, continue with just console
-        pass
-    
-    logger.addHandler(console_handler)
-    
-    return logger
-
-# Global logger instance
-_logger = None
-
-def get_logger() -> logging.Logger:
-    """Get the global logger instance"""
-    global _logger
-    if _logger is None:
-        _logger = setup_logger()
-    return _logger
-
-def log_error(message: str, error: Exception = None) -> None:
-    """Log error messages with optional exception details"""
-    logger = get_logger()
-    if error:
-        logger.error(f"{message}: {str(error)}", exc_info=True)
-    else:
-        logger.error(message)
-
-def log_warning(message: str) -> None:
-    """Log warning messages"""
-    logger = get_logger()
-    logger.warning(message)
-
-def log_info(message: str) -> None:
-    """Log info messages"""
-    logger = get_logger()
-    logger.info(message)
-
-def log_debug(message: str) -> None:
-    """Log debug messages"""
-    logger = get_logger()
-    logger.debug(message)
-
-def log_performance(operation: str, duration: float, additional_info: Dict[str, Any] = None) -> None:
-    """Log performance metrics"""
-    logger = get_logger()
-    perf_data = {
-        "operation": operation,
-        "duration_seconds": round(duration, 4),
-        "timestamp": datetime.now().isoformat()
-    }
-    
-    if additional_info:
-        perf_data.update(additional_info)
-    
-    logger.info(f"PERFORMANCE: {json.dumps(perf_data)}")
-
-def log_user_action(action: str, user_id: str = None, details: Dict[str, Any] = None) -> None:
-    """Log user actions for analytics"""
-    logger = get_logger()
-    action_data = {
-        "action": action,
-        "user_id": user_id or "anonymous",
-        "timestamp": datetime.now().isoformat()
-    }
-    
-    if details:
-        action_data.update(details)
-    
-    logger.info(f"USER_ACTION: {json.dumps(action_data)}")
-
-def log_data_operation(operation: str, table_name: str = None, record_count: int = None, success: bool = True) -> None:
-    """Log database/data operations"""
-    logger = get_logger()
-    data_op = {
-        "operation": operation,
-        "table": table_name,
-        "record_count": record_count,
-        "success": success,
-        "timestamp": datetime.now().isoformat()
-    }
-    
-    level = logging.INFO if success else logging.ERROR
-    logger.log(level, f"DATA_OP: {json.dumps(data_op)}")
-
-def log_api_call(endpoint: str, method: str = "GET", status_code: int = None, duration: float = None) -> None:
-    """Log API calls and responses"""
-    logger = get_logger()
-    api_data = {
-        "endpoint": endpoint,
-        "method": method,
-        "status_code": status_code,
-        "duration_seconds": round(duration, 4) if duration else None,
-        "timestamp": datetime.now().isoformat()
-    }
-    
-    logger.info(f"API_CALL: {json.dumps(api_data)}")
-
-def log_security_event(event_type: str, details: Dict[str, Any] = None, severity: str = "INFO") -> None:
-    """Log security-related events"""
-    logger = get_logger()
-    security_data = {
-        "event_type": event_type,
-        "severity": severity,
-        "timestamp": datetime.now().isoformat()
-    }
-    
-    if details:
-        security_data.update(details)
-    
-    level = getattr(logging, severity.upper(), logging.INFO)
-    logger.log(level, f"SECURITY: {json.dumps(security_data)}")
-
-def log_system_health(component: str, status: str, metrics: Dict[str, Any] = None) -> None:
-    """Log system health checks"""
-    logger = get_logger()
-    health_data = {
-        "component": component,
-        "status": status,
-        "timestamp": datetime.now().isoformat()
-    }
-    
-    if metrics:
-        health_data.update(metrics)
-    
-    level = logging.INFO if status == "healthy" else logging.WARNING
-    logger.log(level, f"HEALTH: {json.dumps(health_data)}")
-
-def log_ai_model_usage(model_name: str, operation: str, tokens_used: Optional[int] = None) -> None:
-    """Log AI model usage for monitoring and billing"""
-    logger = get_logger()
-    ai_data = {
-        "model": model_name,
-        "operation": operation,
-        "tokens_used": tokens_used,
-        "timestamp": datetime.now().isoformat()
-    }
-    
-    logger.info(f"AI_USAGE: {json.dumps(ai_data)}")
-
-def log_business_metric(metric_name: str, value: float, unit: str = None, tags: Dict[str, str] = None) -> None:
-    """Log business metrics for analytics"""
-    logger = get_logger()
-    metric_data = {
-        "metric": metric_name,
-        "value": value,
-        "unit": unit,
-        "timestamp": datetime.now().isoformat()
-    }
-    
-    if tags:
-        metric_data["tags"] = tags
-    
-    logger.info(f"METRIC: {json.dumps(metric_data)}")
-
-# Context manager for performance logging
-class PerformanceLogger:
-    def __init__(self, operation: str, additional_info: Dict[str, Any] = None):
-        self.operation = operation
-        self.additional_info = additional_info or {}
-        self.start_time = None
-    
-    def __enter__(self):
-        self.start_time = datetime.now()
-        return self
-    
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if self.start_time:
-            duration = (datetime.now() - self.start_time).total_seconds()
-            success = exc_type is None
-            
-            perf_info = self.additional_info.copy()
-            perf_info["success"] = success
-            
-            if not success and exc_val:
-                perf_info["error"] = str(exc_val)
-            
-            log_performance(self.operation, duration, perf_info)
-
-# Decorator for automatic performance logging
-def log_performance_decorator(operation_name: str = None):
-    def decorator(func):
-        def wrapper(*args, **kwargs):
-            op_name = operation_name or f"{func.__module__}.{func.__name__}"
-            with PerformanceLogger(op_name):
-                return func(*args, **kwargs)
-        return wrapper
-    return decorator
-# utils/logging.py
-import logging
 import sys
 from datetime import datetime
 
@@ -255,7 +25,7 @@ def get_logger(name=None):
         
         # Create formatter
         formatter = logging.Formatter(
-            '%(levelname)s - %(name)s - %(message)s'
+            'INFO - %(name)s - %(message)s'
         )
         handler.setFormatter(formatter)
         
@@ -282,5 +52,7 @@ def log_error(logger, error, context=""):
 # Initialize logging system
 print(f"===== Application Startup at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
 print("INFO - Logging system initialized")
-# Initialize logger on module import
-get_logger().info("Logging system initialized")
+
+# Create a default logger for the module
+logger = get_logger(__name__)
+logger.info("Logging system initialized")