wip

safe_logging.py

@@ -0,0 +1,112 @@
+import logging
+import sys
+import platform
+import os
+from pathlib import Path
+
+class SafeFormatter(logging.Formatter):
+    """Custom formatter that safely handles non-ASCII characters"""
+    
+    def format(self, record):
+        # Handle message string safely
+        if hasattr(record, 'msg') and record.msg is not None:
+            if isinstance(record.msg, str):
+                # Strip non-ASCII characters to prevent encoding errors
+                record.msg = record.msg.encode("ascii", "ignore").decode()
+            elif isinstance(record.msg, bytes):
+                # Handle bytes objects
+                record.msg = record.msg.decode("utf-8", "ignore")
+        
+        # Handle args tuple if present
+        if hasattr(record, 'args') and record.args:
+            safe_args = []
+            for arg in record.args:
+                if isinstance(arg, str):
+                    safe_args.append(arg.encode("ascii", "ignore").decode())
+                elif isinstance(arg, bytes):
+                    safe_args.append(arg.decode("utf-8", "ignore"))
+                else:
+                    safe_args.append(str(arg))
+            record.args = tuple(safe_args)
+        
+        # Handle exc_text if present
+        if hasattr(record, 'exc_text') and record.exc_text:
+            if isinstance(record.exc_text, str):
+                record.exc_text = record.exc_text.encode("ascii", "ignore").decode()
+        
+        return super().format(record)
+
+class SafeStreamHandler(logging.StreamHandler):
+    """Stream handler that forces UTF-8 encoding where supported"""
+    
+    def __init__(self, stream=None):
+        super().__init__(stream)
+        # Try to set UTF-8 encoding on stdout/stderr if supported
+        if hasattr(self.stream, 'reconfigure'):
+            try:
+                if platform.system() == "Windows":
+                    # On Windows, use errors='ignore'
+                    self.stream.reconfigure(encoding='utf-8', errors='ignore')
+                else:
+                    # On Unix-like systems, use backslashreplace
+                    self.stream.reconfigure(encoding='utf-8', errors='backslashreplace')
+            except (AttributeError, OSError):
+                # If reconfigure is not available or fails, continue silently
+                pass
+
+def setup_safe_logging(log_level=logging.INFO, log_file='logs/safe_logging.log'):
+    """Setup logging with SafeFormatter and UTF-8 encoding
+    
+    Args:
+        log_level: Logging level (default: INFO)
+        log_file: Path to log file (default: logs/safe_logging.log)
+    """
+    # Ensure logs directory exists
+    log_path = Path(log_file)
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Clear existing handlers to avoid duplicates
+    root_logger = logging.getLogger()
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+    
+    # Create handlers with proper encoding
+    handlers = []
+    
+    # Console handler with safe UTF-8 handling
+    console_handler = SafeStreamHandler(sys.stdout)
+    console_handler.setFormatter(SafeFormatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    ))
+    handlers.append(console_handler)
+    
+    # File handler with UTF-8 encoding and error handling
+    try:
+        encoding_kwargs = {
+            "encoding": "utf-8",
+            "errors": "ignore" if platform.system() == "Windows" else "backslashreplace"
+        }
+        
+        file_handler = logging.FileHandler(log_file, **encoding_kwargs)
+        file_handler.setFormatter(SafeFormatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        ))
+        handlers.append(file_handler)
+    except (OSError, IOError) as e:
+        # If file handler fails, just use console handler
+        print(f"Warning: Could not create log file {log_file}: {e}", file=sys.stderr)
+    
+    # Configure root logger
+    logging.basicConfig(
+        level=log_level,
+        handlers=handlers,
+        force=True  # Force reconfiguration
+    )
+    
+    # Apply SafeFormatter to all existing loggers
+    safe_formatter = SafeFormatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    for logger_name in logging.Logger.manager.loggerDict:
+        logger = logging.getLogger(logger_name)
+        for handler in logger.handlers:
+            handler.setFormatter(safe_formatter)
+