Files
universal-web-api/app/core/config_parts/secure_logger.py
T
2026-11-02 22:54:14 +08:00

275 lines
9.3 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""
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")