""" app/core/config_parts/secure_logger.py - 安全日志器实现与日志工厂模块 """ from collections import defaultdict import contextlib import contextvars import logging import sys import threading import time from typing import Any, Dict, Optional from .env_config import AppConfig from .browser_constants import _BrowserConstantEnabledFilter from .log_formatters import ( _compact_logger_name, _ConsoleColorFormatter, _format_log_display_line, _web_log_handler, get_shared_file_log_handler, ) from .cute_translator import ( _cuteify_info_message, _cuteify_debug_message, _cuteify_warning_message, _cuteify_error_message, _add_suppressed_marker, ) # 上下文变量,存储当前请求的 request_id _request_context: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar("request_id", default=None) _command_log_context: contextvars.ContextVar[Optional[Dict[str, Any]]] = contextvars.ContextVar( "command_log_context", default=None, ) _logger_setup_lock = threading.RLock() _logger_registry_lock = threading.Lock() _logger_registry: Dict[str, "SecureLogger"] = {} class SecureLogger: """安全日志器,带图标和格式化(支持上下文自动注入 request_id)""" _debug_throttle_locks: Dict[str, threading.Lock] = defaultdict(threading.Lock) _debug_throttle_state: Dict[str, Dict[str, Any]] = {} ICONS = { 'DEBUG': '▫️', 'INFO': '🔹', 'WARNING': '⚠️', 'ERROR': '❌', 'SUCCESS': '✅', 'STREAM': '🌊', 'NETWORK': '🌐', } # 日志级别映射 LEVEL_MAP = { 'DEBUG': logging.DEBUG, 'INFO': logging.INFO, 'WARNING': logging.WARNING, 'ERROR': logging.ERROR, 'CRITICAL': logging.CRITICAL, } def __init__(self, name: str, level: Optional[int] = None): self._name = _compact_logger_name(name) # 如果未指定级别,从环境变量获取 if level is None: level = self._get_level_from_env() self._level = level self._logger = self._setup_logger(name, level) @classmethod def _get_level_from_env(cls) -> int: """从环境变量获取日志级别""" level_str = AppConfig.get_log_level() return cls.LEVEL_MAP.get(level_str, logging.INFO) def _setup_logger(self, name: str, level: int) -> logging.Logger: logger = logging.getLogger(name) with _logger_setup_lock: # 防止日志向上层冒泡导致重复打印 logger.propagate = False existing_kinds = { getattr(handler, "_codex_secure_handler", None) for handler in logger.handlers } if "console" not in existing_kinds: console_handler = logging.StreamHandler(sys.stdout) console_handler.setLevel(logging.DEBUG) console_handler.setFormatter(_ConsoleColorFormatter()) console_handler.addFilter(_BrowserConstantEnabledFilter("LOG_CONSOLE_ENABLED", True)) setattr(console_handler, "_codex_secure_handler", "console") logger.addHandler(console_handler) file_handler = get_shared_file_log_handler() if file_handler is not None and file_handler not in logger.handlers: logger.addHandler(file_handler) if _web_log_handler not in logger.handlers: logger.addHandler(_web_log_handler) logger.setLevel(logging.DEBUG) return logger def _format(self, level_key: str, msg: str) -> str: """核心格式化逻辑(简洁版)""" record = logging.LogRecord( name=self._name, level=self.LEVEL_MAP.get(str(level_key or "").upper(), logging.INFO), pathname="", lineno=0, msg=str(msg or ""), args=(), exc_info=None, ) record.codex_request_id = _request_context.get() or "SYSTEM" record.codex_logger_name = self._name formatted, _ = _format_log_display_line(record, msg) return formatted def _make_debug_throttle_key(self, key: str) -> str: normalized = str(key or "").strip() or "__default__" return f"{self._name}:{normalized}" @staticmethod def _coerce_bool(value: Any, default: bool = True) -> bool: if value is None: return default if isinstance(value, bool): return value if isinstance(value, (int, float)): return bool(value) text = str(value).strip().lower() if text in {"1", "true", "yes", "y", "on"}: return True if text in {"0", "false", "no", "n", "off"}: return False return default def _get_effective_emit_level(self) -> Optional[int]: context = _command_log_context.get() if not isinstance(context, dict): return self._level if not self._coerce_bool(context.get("enabled", True), True): return None override = str(context.get("level", "GLOBAL") or "GLOBAL").strip().upper() if override == "GLOBAL": return self._level return self.LEVEL_MAP.get(override, self._level) def _emit(self, level: int, level_key: str, msg: str, *, exc_info: bool = False): effective_level = self._get_effective_emit_level() if effective_level is None or level < effective_level: return request_id = _request_context.get() or "SYSTEM" original_message_text = str(msg or "") upper_level_key = str(level_key or "").upper() # P0-7:展示层翻译(cute_translator)改为惰性:由 handler 渲染时经 # log_formatters._record_display_message 计算一次并缓存到 record 上。 self._logger.log( level, original_message_text, exc_info=exc_info, extra={ "codex_request_id": request_id, "codex_logger_name": self._name, "codex_message": original_message_text, "codex_original_message_text": original_message_text, "codex_display_pending": True, "codex_kind": upper_level_key, }, ) def set_level(self, level: int): """动态调整日志级别""" self._level = level self._logger.setLevel(logging.DEBUG) for handler in self._logger.handlers: handler.setLevel(logging.DEBUG) def debug(self, msg: str): self._emit(logging.DEBUG, 'DEBUG', msg) def debug_throttled(self, key: str, msg: str, interval_sec: float = 5.0): """在高频路径里限频输出 DEBUG,并附带被抑制次数。""" effective_level = self._get_effective_emit_level() if effective_level is None or logging.DEBUG < effective_level: return now = time.time() interval = max(0.0, float(interval_sec or 0.0)) throttle_key = self._make_debug_throttle_key(key) suppressed = 0 should_log = False lock = self._debug_throttle_locks[throttle_key] with lock: state = self._debug_throttle_state.get(throttle_key) last_at = float(state.get("last_at", 0.0) or 0.0) if state else 0.0 if state is None or (now - last_at) >= interval: suppressed = int(state.get("suppressed", 0) or 0) if state else 0 self._debug_throttle_state[throttle_key] = { "last_at": now, "suppressed": 0, } should_log = True else: state["suppressed"] = int(state.get("suppressed", 0) or 0) + 1 if should_log: self.debug(_add_suppressed_marker(msg, suppressed)) def info(self, msg: str): self._emit(logging.INFO, 'INFO', msg) def warning(self, msg: str): self._emit(logging.WARNING, 'WARNING', msg) def error(self, msg: str): self._emit(logging.ERROR, 'ERROR', msg) def exception(self, msg: str): self._emit(logging.ERROR, 'ERROR', msg, exc_info=True) def success(self, msg: str): self._emit(logging.INFO, 'SUCCESS', msg) def stream(self, msg: str): self._emit(logging.INFO, 'STREAM', msg) def network(self, msg: str): self._emit(logging.INFO, 'NETWORK', msg) @contextlib.contextmanager def context(self, request_id: str): """上下文管理器,用于在代码块中自动设置 request_id""" token = _request_context.set(request_id) try: yield finally: _request_context.reset(token) @contextlib.contextmanager def command_log_context(config: Optional[Dict[str, Any]] = None): token = _command_log_context.set(config if isinstance(config, dict) else None) try: yield finally: _command_log_context.reset(token) def get_logger(name: str) -> SecureLogger: """获取 SecureLogger 实例(统一日志入口)""" normalized = str(name or "APP").strip() or "APP" with _logger_registry_lock: instance = _logger_registry.get(normalized) if instance is None: instance = SecureLogger(normalized) _logger_registry[normalized] = instance return instance # 创建常用 logger 实例(向后兼容) logger = get_logger("BROWSER")