Refactor: add rxtx debugger log

detector_worker/utils/websocket_debug.py

@@ -0,0 +1,165 @@
+"""
+WebSocket debugging utilities.
+
+This module provides utilities for configuring WebSocket logging and debugging
+based on configuration settings.
+"""
+import logging
+import sys
+from typing import Optional
+from pathlib import Path
+
+from ..core.config import get_config_manager
+
+
+def setup_websocket_logging(
+    enable_debug: Optional[bool] = None,
+    rxtx_log_level: Optional[str] = None,
+    message_proc_log_level: Optional[str] = None,
+    log_file: Optional[str] = None
+) -> None:
+    """
+    Set up WebSocket logging based on configuration.
+    
+    Args:
+        enable_debug: Enable WebSocket debugging (overrides config)
+        rxtx_log_level: Log level for RX/TX messages (overrides config)
+        message_proc_log_level: Log level for message processing (overrides config)
+        log_file: Optional log file path for WebSocket messages
+    """
+    # Get configuration
+    config_manager = get_config_manager()
+    logging_config = config_manager.get_logging_config()
+    
+    # Use provided values or fall back to config
+    debug_enabled = enable_debug if enable_debug is not None else logging_config.websocket_debug
+    rxtx_level = rxtx_log_level or logging_config.websocket_rxtx_log_level
+    msg_proc_level = message_proc_log_level or logging_config.websocket_message_proc_log_level
+    
+    # Configure WebSocket RX/TX logger
+    ws_rxtx_logger = logging.getLogger("websocket.rxtx")
+    ws_rxtx_logger.setLevel(getattr(logging, rxtx_level.upper(), logging.INFO))
+    
+    # Configure WebSocket message processor logger  
+    ws_msg_proc_logger = logging.getLogger("websocket.message_processor")
+    ws_msg_proc_logger.setLevel(getattr(logging, msg_proc_level.upper(), logging.DEBUG))
+    
+    # Configure main WebSocket logger
+    ws_logger = logging.getLogger("websocket")
+    ws_logger.setLevel(logging.DEBUG if debug_enabled else logging.INFO)
+    
+    # Set up console handler for debugging if not already present
+    if debug_enabled and not ws_rxtx_logger.handlers:
+        # Create console handler
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setLevel(getattr(logging, rxtx_level.upper(), logging.INFO))
+        
+        # Create formatter for WebSocket messages
+        formatter = logging.Formatter(
+            "%(asctime)s | WEBSOCKET | %(name)s | %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S"
+        )
+        console_handler.setFormatter(formatter)
+        
+        # Add handler to both WebSocket loggers
+        ws_rxtx_logger.addHandler(console_handler)
+        ws_msg_proc_logger.addHandler(console_handler)
+        
+    # Set up file handler if log file is specified
+    if log_file:
+        log_path = Path(log_file)
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Create file handler
+        file_handler = logging.FileHandler(log_path)
+        file_handler.setLevel(logging.DEBUG)
+        
+        # Create detailed formatter for file output
+        file_formatter = logging.Formatter(
+            "%(asctime)s | %(levelname)s | %(name)s | %(message)s"
+        )
+        file_handler.setFormatter(file_formatter)
+        
+        # Add to all WebSocket loggers
+        ws_rxtx_logger.addHandler(file_handler)
+        ws_msg_proc_logger.addHandler(file_handler)
+        ws_logger.addHandler(file_handler)
+        
+    # Log configuration status
+    main_logger = logging.getLogger("detector_worker.websocket_debug")
+    main_logger.info(f"WebSocket debugging configured: "
+                    f"enabled={debug_enabled}, "
+                    f"rxtx_level={rxtx_level}, "
+                    f"msg_proc_level={msg_proc_level}, "
+                    f"log_file={log_file}")
+
+
+def enable_websocket_debug() -> None:
+    """Enable WebSocket debugging with default settings."""
+    setup_websocket_logging(
+        enable_debug=True,
+        rxtx_log_level="INFO",
+        message_proc_log_level="DEBUG"
+    )
+
+
+def disable_websocket_debug() -> None:
+    """Disable WebSocket debugging."""
+    # Set all WebSocket loggers to WARNING level to reduce noise
+    ws_loggers = [
+        "websocket",
+        "websocket.rxtx", 
+        "websocket.message_processor"
+    ]
+    
+    for logger_name in ws_loggers:
+        logger = logging.getLogger(logger_name)
+        logger.setLevel(logging.WARNING)
+        
+        # Remove all handlers
+        for handler in logger.handlers[:]:
+            logger.removeHandler(handler)
+
+
+def get_websocket_debug_status() -> dict:
+    """
+    Get current WebSocket debugging status.
+    
+    Returns:
+        Dictionary with debugging status information
+    """
+    config_manager = get_config_manager()
+    logging_config = config_manager.get_logging_config()
+    
+    # Check current logger levels
+    ws_rxtx_logger = logging.getLogger("websocket.rxtx")
+    ws_msg_proc_logger = logging.getLogger("websocket.message_processor")
+    ws_logger = logging.getLogger("websocket")
+    
+    return {
+        "config": {
+            "websocket_debug": logging_config.websocket_debug,
+            "websocket_rxtx_log_level": logging_config.websocket_rxtx_log_level,
+            "websocket_message_proc_log_level": logging_config.websocket_message_proc_log_level
+        },
+        "runtime": {
+            "websocket_logger_level": logging.getLevelName(ws_logger.level),
+            "rxtx_logger_level": logging.getLevelName(ws_rxtx_logger.level),
+            "msg_proc_logger_level": logging.getLevelName(ws_msg_proc_logger.level),
+            "handler_count": {
+                "websocket": len(ws_logger.handlers),
+                "rxtx": len(ws_rxtx_logger.handlers),
+                "msg_proc": len(ws_msg_proc_logger.handlers)
+            }
+        }
+    }
+
+
+def log_websocket_stats() -> None:
+    """Log WebSocket communication statistics."""
+    logger = logging.getLogger("websocket.stats")
+    
+    # This could be extended to track actual message counts
+    # For now, just log the current status
+    status = get_websocket_debug_status()
+    logger.info(f"WebSocket Debug Status: {status}")