update code

utils/logging_utils.py

@@ -0,0 +1,120 @@
+"""
+Logging utility functions
+"""
+
+import logging
+import time
+from functools import wraps
+from typing import Callable, Any
+
+
+def setup_logging(level: int = logging.INFO, log_file: str = None) -> None:
+    """Setup logging configuration"""
+    handlers = [logging.StreamHandler()]
+
+    if log_file:
+        handlers.append(logging.FileHandler(log_file))
+
+    # Improved log format, includes code location information
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(funcName)s() - %(message)s"
+    )
+
+    for handler in handlers:
+        handler.setFormatter(formatter)
+
+    logging.basicConfig(level=level, handlers=handlers)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get logger with specified name"""
+    return logging.getLogger(name)
+
+
+def log_execution_time(func: Callable) -> Callable:
+    """Decorator to record function execution time"""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> Any:
+        logger = get_logger(func.__module__)
+        start_time = time.time()
+
+        logger.info(f"Starting execution: {func.__name__}")
+
+        try:
+            result = func(*args, **kwargs)
+            execution_time = time.time() - start_time
+            logger.info(
+                f"Completed execution: {func.__name__}, took {execution_time:.2f} seconds"
+            )
+            return result
+        except Exception as e:
+            execution_time = time.time() - start_time
+            logger.error(
+                f"Execution failed: {func.__name__}, took {execution_time:.2f} seconds, error: {e}"
+            )
+            raise
+
+    return wrapper
+
+
+def log_errors(func: Callable) -> Callable:
+    """Decorator to record errors and stack traces
+
+    Usage example:
+        @log_errors
+        def my_function():
+            # Function code
+            pass
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> Any:
+        logger = get_logger(func.__module__)
+
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            # Use logger.exception to automatically record stack trace
+            logger.exception(f"Function {func.__name__} execution failed: {e}")
+            raise
+
+    return wrapper
+
+
+def log_with_context(context: str = None):
+    """Error logging decorator with context
+
+    Usage example:
+        @log_with_context("Processing user request")
+        def process_request():
+            pass
+
+        @log_with_context("Processing data")
+        def process_data(self, data):
+            pass
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            # Use the module name where the function is located
+            logger = get_logger(func.__module__)
+            func_name = func.__name__
+            context_str = f" [{context}]" if context else ""
+
+            logger.debug(f"Starting execution{context_str}: {func_name}")
+
+            try:
+                result = func(*args, **kwargs)
+                logger.debug(f"Completed execution{context_str}: {func_name}")
+                return result
+            except Exception as e:
+                logger.exception(
+                    f"Execution failed{context_str}: {func_name}, error: {e}"
+                )
+                raise
+
+        return wrapper
+
+    return decorator