Initial commit

This commit is contained in:
Alex committed 2026-11-02 22:54:14 +08:00
commit 57fc3525eb
7311 files changed
+1291398

No files matched your search

+274
View File
@@ -0,0 +1,274 @@
"""
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")