realtimex-deeptutor 0.5.0.post1__py3-none-any.whl → 0.5.0.post3__py3-none-any.whl

src/logging/config.py

@@ -1,43 +1,38 @@
+# -*- coding: utf-8 -*-
 """
 Logging Configuration
 =====================
 
-Configuration settings for the logging system.
+Unified logging configuration for the entire DeepTutor system.
+A single `level` parameter controls all logging (including RAG modules).
 """
 
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
+from typing import Dict, Optional
 
 
 @dataclass
 class LoggingConfig:
     """Configuration for the logging system."""
 
+    # Global log level (controls entire system including RAG modules)
+    level: str = "DEBUG"
+
     # Output settings
     console_output: bool = True
     file_output: bool = True
 
-    # Log levels
-    console_level: str = "INFO"
-    file_level: str = "DEBUG"
-
     # Log directory (relative to project root or absolute)
     log_dir: Optional[str] = None
 
+    # RAG module logger name mapping
+    rag_logger_names: Optional[Dict[str, str]] = None
+
     # File rotation settings
     max_bytes: int = 10 * 1024 * 1024  # 10MB
     backup_count: int = 5
 
-    # WebSocket streaming
-    websocket_enabled: bool = True
-    websocket_queue_size: int = 1000
-
-    # LightRAG forwarding
-    lightrag_forwarding_enabled: bool = True
-    lightrag_min_level: str = "INFO"
-    lightrag_add_prefix: bool = True
-
 
 def get_default_log_dir() -> Path:
     """Get the default log directory."""
@@ -45,6 +40,22 @@ def get_default_log_dir() -> Path:
     return project_root / "data" / "user" / "logs"
 
 
+def get_global_log_level() -> str:
+    """
+    Get the global log level from config/main.yaml -> logging.level
+    Default: DEBUG
+    """
+    try:
+        from src.services.config import load_config_with_main
+
+        project_root = Path(__file__).resolve().parent.parent.parent
+        config = load_config_with_main("solve_config.yaml", project_root)
+        logging_config = config.get("logging", {})
+        return logging_config.get("level", "DEBUG").upper()
+    except Exception:
+        return "DEBUG"
+
+
 def load_logging_config() -> LoggingConfig:
     """
     Load logging configuration from config files.
@@ -59,22 +70,14 @@ def load_logging_config() -> LoggingConfig:
         config = load_config_with_main("solve_config.yaml", project_root)
 
         logging_config = config.get("logging", {})
+        level = get_global_log_level()
 
         return LoggingConfig(
+            level=level,
             console_output=logging_config.get("console_output", True),
-            file_output=logging_config.get("file_output", True),
-            console_level=logging_config.get("console_level", "INFO"),
-            file_level=logging_config.get("file_level", "DEBUG"),
+            file_output=logging_config.get("save_to_file", True),
             log_dir=get_path_from_config(config, "user_log_dir"),
-            lightrag_forwarding_enabled=logging_config.get("lightrag_forwarding", {}).get(
-                "enabled", True
-            ),
-            lightrag_min_level=logging_config.get("lightrag_forwarding", {}).get(
-                "min_level", "INFO"
-            ),
-            lightrag_add_prefix=logging_config.get("lightrag_forwarding", {}).get(
-                "add_prefix", True
-            ),
+            rag_logger_names=logging_config.get("rag_logger_names"),
         )
     except Exception:
         return LoggingConfig()

src/logging/handlers/__init__.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 """
 Log Handlers
 ============

src/logging/handlers/console.py

@@ -3,59 +3,15 @@
 Console Log Handler
 ===================
 
-Color-coded console output with symbols.
+Color-coded console output with standard level tags.
 """
 
 import logging
 import sys
+from typing import Optional
 
-
-class ConsoleFormatter(logging.Formatter):
-    """
-    Clean console formatter with colors and symbols.
-    Format: [Module]    Symbol Message
-    """
-
-    # ANSI color codes
-    COLORS = {
-        "DEBUG": "\033[90m",  # Gray
-        "INFO": "\033[37m",  # White
-        "SUCCESS": "\033[32m",  # Green
-        "WARNING": "\033[33m",  # Yellow
-        "ERROR": "\033[31m",  # Red
-        "CRITICAL": "\033[35m",  # Magenta
-    }
-    RESET = "\033[0m"
-    BOLD = "\033[1m"
-    DIM = "\033[2m"
-
-    # Symbols for different log types
-    SYMBOLS = {
-        "DEBUG": "·",
-        "INFO": "●",
-        "SUCCESS": "✓",
-        "WARNING": "⚠",
-        "ERROR": "✗",
-        "CRITICAL": "✗",
-    }
-
-    def format(self, record: logging.LogRecord) -> str:
-        # Get module name (padded to 12 chars for alignment)
-        module = getattr(record, "module_name", record.name)
-        module_padded = f"[{module}]".ljust(14)
-
-        # Get symbol (can be overridden via record.symbol)
-        symbol = getattr(record, "symbol", self.SYMBOLS.get(record.levelname, "●"))
-
-        # Get color
-        level = getattr(record, "display_level", record.levelname)
-        color = self.COLORS.get(level, self.COLORS["INFO"])
-
-        # Format message
-        message = record.getMessage()
-
-        # Build output: [Module]    ● Message
-        return f"{self.DIM}{module_padded}{self.RESET} {color}{symbol}{self.RESET} {message}"
+# Import ConsoleFormatter from the main logger module to avoid duplication
+from ..logger import ConsoleFormatter
 
 
 class ConsoleHandler(logging.StreamHandler):
@@ -63,13 +19,14 @@ class ConsoleHandler(logging.StreamHandler):
     Console handler with color-coded output.
     """
 
-    def __init__(self, level: int = logging.INFO):
+    def __init__(self, level: int = logging.INFO, service_prefix: Optional[str] = None):
         """
         Initialize console handler.
 
         Args:
             level: Minimum log level to display
+            service_prefix: Optional service layer prefix (e.g., "Backend", "Frontend")
         """
         super().__init__(sys.stdout)
         self.setLevel(level)
-        self.setFormatter(ConsoleFormatter())
+        self.setFormatter(ConsoleFormatter(service_prefix=service_prefix))

src/logging/handlers/file.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 """
 File Log Handlers
 =================
@@ -13,24 +14,8 @@ from logging.handlers import RotatingFileHandler as BaseRotatingFileHandler
 from pathlib import Path
 from typing import Optional
 
-
-class FileFormatter(logging.Formatter):
-    """
-    Detailed file formatter for log files.
-    Format: TIMESTAMP [LEVEL] [Module] Message
-    """
-
-    def __init__(self):
-        super().__init__(
-            fmt="%(asctime)s [%(levelname)-8s] [%(module_name)-12s] %(message)s",
-            datefmt="%Y-%m-%d %H:%M:%S",
-        )
-
-    def format(self, record: logging.LogRecord) -> str:
-        # Ensure module_name exists
-        if not hasattr(record, "module_name"):
-            record.module_name = record.name
-        return super().format(record)
+# Import FileFormatter from the main logger module to avoid duplication
+from ..logger import FileFormatter
 
 
 class FileHandler(logging.FileHandler):
@@ -143,7 +128,7 @@ class JSONFileHandler(logging.Handler):
             }
 
             # Add extra fields if present
-            for key in ["symbol", "display_level", "tool_name", "elapsed_ms", "tokens"]:
+            for key in ["display_level", "tool_name", "elapsed_ms", "tokens"]:
                 if hasattr(record, key):
                     entry[key] = getattr(record, key)
 
@@ -180,7 +165,7 @@ def create_task_logger(
     log_path.mkdir(parents=True, exist_ok=True)
 
     # Create logger
-    logger = logging.getLogger(f"ai_tutor.{module_name}.{task_id}")
+    logger = logging.getLogger(f"deeptutor.{module_name}.{task_id}")
     logger.setLevel(logging.DEBUG)
     logger.handlers.clear()
     logger.propagate = False

src/logging/handlers/websocket.py

@@ -8,6 +8,7 @@ Handlers for streaming logs to WebSocket clients.
 
 import asyncio
 import logging
+from typing import Optional
 
 
 class WebSocketLogHandler(logging.Handler):
@@ -25,27 +26,24 @@ class WebSocketLogHandler(logging.Handler):
             await websocket.send_json(log_entry)
     """
 
-    # Symbols for different log types (matching ConsoleFormatter)
-    SYMBOLS = {
-        "DEBUG": "·",
-        "INFO": "●",
-        "SUCCESS": "✓",
-        "WARNING": "⚠",
-        "ERROR": "✗",
-        "CRITICAL": "✗",
-    }
-
-    def __init__(self, queue: asyncio.Queue, include_module: bool = True):
+    def __init__(
+        self,
+        queue: asyncio.Queue,
+        include_module: bool = True,
+        service_prefix: Optional[str] = None,
+    ):
         """
         Initialize WebSocket log handler.
 
         Args:
             queue: asyncio.Queue to put log entries into
             include_module: Whether to include module name in output
+            service_prefix: Optional service layer prefix (e.g., "Backend")
         """
         super().__init__()
         self.queue = queue
         self.include_module = include_module
+        self.service_prefix = service_prefix
         self.setFormatter(logging.Formatter("%(message)s"))
 
     def emit(self, record: logging.LogRecord):
@@ -53,25 +51,31 @@ class WebSocketLogHandler(logging.Handler):
         try:
             msg = self.format(record)
 
-            # Get symbol
+            # Get display level
             display_level = getattr(record, "display_level", record.levelname)
-            symbol = getattr(record, "symbol", self.SYMBOLS.get(display_level, "●"))
 
             # Get module name
             module_name = getattr(record, "module_name", record.name)
 
-            # Build formatted content
-            if self.include_module:
-                content = f"[{module_name}] {symbol} {msg}"
+            # Build formatted content with standard level tags (compact format)
+            level_tag = display_level
+            if self.service_prefix:
+                service_tag = f"[{self.service_prefix}]"
+                if self.include_module:
+                    content = f"{service_tag} {level_tag} [{module_name}] {msg}"
+                else:
+                    content = f"{service_tag} {level_tag} {msg}"
             else:
-                content = f"{symbol} {msg}"
+                if self.include_module:
+                    content = f"{level_tag} [{module_name}] {msg}"
+                else:
+                    content = f"{level_tag} {msg}"
 
             # Construct structured message
             log_entry = {
                 "type": "log",
                 "level": display_level,
                 "module": module_name,
-                "symbol": symbol,
                 "content": content,
                 "message": msg,
                 "timestamp": record.created,
@@ -93,7 +97,7 @@ class LogInterceptor:
 
     Usage:
         queue = asyncio.Queue()
-        logger = logging.getLogger("ai_tutor.Solver")
+        logger = logging.getLogger("deeptutor.Solver")
 
         with LogInterceptor(logger, queue):
             # All logs from this logger will be streamed to queue