Update utils/logging.py

utils/logging.py

@@ -1,71 +1,157 @@
-# utils/logging.py
+"""
+Logging utilities for the MONA application
+Fixed version with all required functions
+"""
 
 import logging
+import os
 import sys
 from datetime import datetime
+from pathlib import Path
 
-def get_logger(name=None):
+
+def setup_logging(log_level=logging.INFO, log_file=None):
     """
-    Get a configured logger instance
+    Set up logging configuration
     
     Args:
-        name (str, optional): Logger name, typically __name__
+        log_level: Logging level (default: INFO)
+        log_file: Optional log file path
+    """
+    # Create logs directory if it doesn't exist
+    if log_file:
+        log_dir = Path(log_file).parent
+        log_dir.mkdir(exist_ok=True)
+    
+    # Configure logging format
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    
+    # Set up root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(log_level)
+    
+    # Clear existing handlers
+    root_logger.handlers.clear()
+    
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    root_logger.addHandler(console_handler)
+    
+    # File handler if specified
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        root_logger.addHandler(file_handler)
+
+
+def get_logger(name=None):
+    """
+    Get a logger instance
     
+    Args:
+        name: Logger name (default: __name__)
+        
     Returns:
-        logging.Logger: Configured logger instance
+        logging.Logger: Logger instance
     """
     if name is None:
         name = __name__
     
     logger = logging.getLogger(name)
     
-    # Only add handler if logger doesn't already have one
-    if not logger.handlers:
-        # Create console handler
-        handler = logging.StreamHandler(sys.stdout)
-        handler.setLevel(logging.INFO)
-        
-        # Create formatter
-        formatter = logging.Formatter(
-            'INFO - %(name)s - %(message)s'
-        )
-        handler.setFormatter(formatter)
-        
-        # Add handler to logger
-        logger.addHandler(handler)
-        logger.setLevel(logging.INFO)
+    # If no handlers are set up, set up basic logging
+    if not logger.handlers and not logging.getLogger().handlers:
+        setup_logging()
     
     return logger
 
-def log_error(logger, error, context=""):
+
+def log_error(message, error=None, extra_data=None):
+    """
+    Log error messages with optional error details and extra data
+    
+    Args:
+        message (str): The error message to log
+        error (Exception, optional): The exception object if available
+        extra_data (dict, optional): Additional data to include in log
+    """
+    logger = get_logger()
+    
+    if error:
+        error_msg = f"{message}: {str(error)}"
+        if hasattr(error, '__traceback__'):
+            import traceback
+            error_msg += f"\nTraceback: {traceback.format_exc()}"
+    else:
+        error_msg = message
+    
+    if extra_data:
+        logger.error(error_msg, extra=extra_data)
+    else:
+        logger.error(error_msg)
+
+
+def log_warning(message, extra_data=None):
     """
-    Log error with context information
+    Log warning messages
     
     Args:
-        logger: Logger instance
-        error: Exception or error message
-        context (str): Additional context information
+        message (str): The warning message to log
+        extra_data (dict, optional): Additional data to include in log
     """
-    if context:
-        logger.error(f"{context}: {str(error)}")
+    logger = get_logger()
+    if extra_data:
+        logger.warning(message, extra=extra_data)
     else:
-        logger.error(str(error))
+        logger.warning(message)
 
-def log_performance(event_name: str, duration_ms: float):
+
+def log_info(message, extra_data=None):
+    """
+    Log info messages
+    
+    Args:
+        message (str): The info message to log
+        extra_data (dict, optional): Additional data to include in log
     """
-    Log performance timing for an event.
+    logger = get_logger()
+    if extra_data:
+        logger.info(message, extra=extra_data)
+    else:
+        logger.info(message)
 
+
+def log_debug(message, extra_data=None):
+    """
+    Log debug messages
+    
+    Args:
+        message (str): The debug message to log
+        extra_data (dict, optional): Additional data to include in log
+    """
+    logger = get_logger()
+    if extra_data:
+        logger.debug(message, extra=extra_data)
+    else:
+        logger.debug(message)
+
+
+def log_exception(message, exc_info=True):
+    """
+    Log exceptions with full traceback
+    
     Args:
-        event_name (str): Name of the event or function
-        duration_ms (float): Duration in milliseconds
+        message (str): The exception message to log
+        exc_info (bool): Whether to include exception info
     """
     logger = get_logger()
-    logger.info(f"⏱️ {event_name} took {duration_ms:.2f} ms")
+    logger.exception(message, exc_info=exc_info)
 
-# Initialize logging system
-print(f"===== Application Startup at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
-print("INFO - Logging system initialized")
 
-# Create a default logger for the module
-logger = get_logger(__name__)
-logger.info("Logging system initialized")
+# Initialize logging when module is imported
+if __name__ != "__main__":
+    setup_logging()