sycommon-python-lib 0.2.10a19__tar.gz → 0.2.10a20__tar.gz

{sycommon_python_lib-0.2.10a19 → sycommon_python_lib-0.2.10a20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.10a19
+Version: 0.2.10a20
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -24,7 +24,7 @@ Requires-Dist: langgraph-checkpoint-redis==0.5.2
 Requires-Dist: ldap3==2.9.1
 Requires-Dist: loguru==0.7.3
 Requires-Dist: mysql-connector-python==26.7.0
-Requires-Dist: nacos-sdk-python<3.0,==2.0.11
+Requires-Dist: nacos-sdk-python==3.2.0
 Requires-Dist: psutil==7.2.2
 Requires-Dist: pyxxl==0.4.8
 Requires-Dist: pydantic==2.14.1

{sycommon_python_lib-0.2.10a19 → sycommon_python_lib-0.2.10a20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.10a19"
+version = "0.2.10a20"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -25,7 +25,7 @@ dependencies = [
     "ldap3==2.9.1",
     "loguru==0.7.3",
     "mysql-connector-python==26.7.0",
-    "nacos-sdk-python==2.0.11,<3.0",
+    "nacos-sdk-python==3.2.0",
     "psutil==7.2.2",
     "pyxxl==0.4.8",
     "pydantic==2.14.1",

sycommon_python_lib-0.2.10a20/src/sycommon/heartbeat_process/__init__.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+"""心跳进程模块（RabbitMQ 连接监控部分保留）。
+
+历史：此进程原先同时承担 Nacos 心跳与 RabbitMQ 连接监控。迁移到
+nacos-sdk-python 3.x（gRPC）后，Nacos 侧保活/断线重连/重注册全部由
+SDK 内部完成（connection keepalive + redo 自动补注册），应用层心跳
+体系（线程心跳 + 本进程的 Nacos 心跳）已整体删除，本进程仅剩
+RabbitMQ 连通性监控职责，由 RabbitMQService 按进程模式开关启用。
+"""
+
+from sycommon.heartbeat_process.heartbeat_process_manager import HeartbeatProcessManager
+from sycommon.heartbeat_process.heartbeat_config import (
+    RabbitMQMonitorConfig,
+    LogConfig
+)
+
+__all__ = [
+    'HeartbeatProcessManager',
+    'RabbitMQMonitorConfig',
+    'LogConfig',
+]
+
+__version__ = '2.0.0'

{sycommon_python_lib-0.2.10a19 → sycommon_python_lib-0.2.10a20}/src/sycommon/heartbeat_process/heartbeat_config.py

@@ -4,54 +4,15 @@
 
 用于在主进程和心跳进程之间传递配置信息。
 使用 dataclass 确保配置可序列化（multiprocessing 需要可序列化的对象）。
+
+注：Nacos 心跳配置(NacosHeartbeatConfig)已随 nacos-sdk-python 3.x
+gRPC 迁移删除——SDK 内建连接保活与断线自动重注册,不再有应用层心跳。
 """
 
 from dataclasses import dataclass, field
 from typing import Optional, Dict, Any
 
 
-@dataclass
-class NacosHeartbeatConfig:
-    """Nacos 心跳配置（可序列化）
-
-    用于独立进程中的 Nacos 心跳发送。
-    包含建立 Nacos 连接和发送心跳所需的所有信息。
-    """
-    server_addresses: str           # Nacos 服务器地址，如 "nacos.example.com:8848"
-    namespace_id: str               # 命名空间 ID
-    service_name: str               # 服务名称
-    real_ip: str                    # 服务真实 IP
-    port: int                       # 服务端口
-    version: Optional[str] = None   # 服务版本
-    heartbeat_interval: int = 15    # 心跳间隔（秒）
-    heartbeat_timeout: int = 15     # 心跳超时（秒）
-    username: Optional[str] = None  # Nacos 用户名
-    password: Optional[str] = None  # Nacos 密码
-
-    @classmethod
-    def from_dict(cls, config: dict) -> 'NacosHeartbeatConfig':
-        """从字典创建配置对象
-
-        Args:
-            config: Nacos 配置字典，通常来自 NacosService 的配置
-
-        Returns:
-            NacosHeartbeatConfig 实例
-        """
-        return cls(
-            server_addresses=config.get('registerIp', ''),
-            namespace_id=config.get('namespaceId', ''),
-            service_name=config.get('serviceName', ''),
-            real_ip=config.get('ip', ''),
-            port=int(config.get('port', 8080)),
-            version=config.get('version'),
-            heartbeat_interval=int(config.get('heartbeatInterval', 15)),
-            heartbeat_timeout=int(config.get('heartbeatTimeout', 15)),
-            username=config.get('username'),
-            password=config.get('password')
-        )
-
-
 @dataclass
 class RabbitMQMonitorConfig:
     """RabbitMQ 连接监控配置（可序列化）

{sycommon_python_lib-0.2.10a19 → sycommon_python_lib-0.2.10a20}/src/sycommon/heartbeat_process/heartbeat_process_manager.py

@@ -8,7 +8,7 @@
 
 注意：
 - MQ 消息消费/发送仍在主进程
-- 心跳进程只负责 Nacos 心跳和 MQ 连接监控
+- 心跳进程只负责 MQ 连接监控（Nacos 心跳已随 gRPC SDK 迁移移除）
 - 通过环境变量 HEARTBEAT_PROCESS_MODE 或配置启用进程模式
 """
 
@@ -20,7 +20,6 @@ from multiprocessing.synchronize import Event as EventType
 from typing import Optional
 
 from sycommon.heartbeat_process.heartbeat_config import (
-    NacosHeartbeatConfig,
     RabbitMQMonitorConfig,
     LogConfig
 )
@@ -66,12 +65,12 @@ class HeartbeatProcessManager:
 
     注意：
     - MQ 消息消费/发送仍在主进程
-    - 心跳进程只负责 Nacos 心跳和 MQ 连接监控
+    - 心跳进程只负责 MQ 连接监控
 
     使用方式：
         # 方式一：代码开关
         HeartbeatProcessManager.enable_process_mode(True)
-        HeartbeatProcessManager.start(nacos_config=config)
+        HeartbeatProcessManager.start(rabbitmq_config=config)
 
         # 方式二：环境变量
         os.environ['HEARTBEAT_PROCESS_MODE'] = 'true'
@@ -129,14 +128,12 @@ class HeartbeatProcessManager:
     @classmethod
     def start(
         cls,
-        nacos_config: Optional[NacosHeartbeatConfig] = None,
         rabbitmq_config: Optional[RabbitMQMonitorConfig] = None,
         log_config: Optional[LogConfig] = None
     ) -> bool:
-        """启动心跳进程
+        """启动心跳进程（RabbitMQ 连接监控）
 
         Args:
-            nacos_config: Nacos 心跳配置
             rabbitmq_config: RabbitMQ 连接监控配置
             log_config: 日志配置（用于在独立进程中初始化日志系统）
 
@@ -144,7 +141,7 @@ class HeartbeatProcessManager:
             bool: 启动是否成功
 
         注意:
-            - 心跳进程启动后，Nacos 心跳和 MQ 连接监控将在独立进程运行
+            - 心跳进程启动后，MQ 连接监控将在独立进程运行
             - MQ 消息的消费和发送仍在主进程
             - 主进程退出时会自动清理子进程
         """
@@ -156,7 +153,7 @@ class HeartbeatProcessManager:
             logger.warning("心跳进程已在运行")
             return True
 
-        if nacos_config is None and rabbitmq_config is None:
+        if rabbitmq_config is None:
             logger.warning("未提供任何配置，跳过启动心跳进程")
             return False
 
@@ -170,7 +167,7 @@ class HeartbeatProcessManager:
             # 使用 fork 上下文创建进程
             cls._process = ctx.Process(
                 target=cls._run_worker,
-                args=(nacos_config, rabbitmq_config,
+                args=(rabbitmq_config,
                       cls._stop_event, log_config),
                 name="HeartbeatProcess",
                 daemon=False  # 非守护进程，确保能正确清理
@@ -191,7 +188,6 @@ class HeartbeatProcessManager:
 
     @staticmethod
     def _run_worker(
-        nacos_config: Optional[NacosHeartbeatConfig],
         rabbitmq_config: Optional[RabbitMQMonitorConfig],
         stop_event: EventType,
         log_config: Optional[LogConfig] = None
@@ -201,7 +197,6 @@ class HeartbeatProcessManager:
         此函数在独立进程中执行。
 
         Args:
-            nacos_config: Nacos 心跳配置
             rabbitmq_config: RabbitMQ 连接监控配置
             stop_event: 停止信号
             log_config: 日志配置
@@ -210,7 +205,6 @@ class HeartbeatProcessManager:
 
         worker = HeartbeatProcessWorker(
             stop_event=stop_event,
-            nacos_config=nacos_config,
             rabbitmq_config=rabbitmq_config,
             log_config=log_config
         )

{sycommon_python_lib-0.2.10a19 → sycommon_python_lib-0.2.10a20}/src/sycommon/heartbeat_process/heartbeat_process_worker.py

@@ -3,8 +3,10 @@
 心跳进程工作器
 
 在独立进程中运行，负责：
-1. Nacos 心跳发送（定期向 Nacos 注册中心发送心跳）
-2. RabbitMQ 连接存活监控（检查连接是否正常，发送告警）
+1. RabbitMQ 连接存活监控（检查连接是否正常，发送告警）
+
+注：Nacos 心跳已随 nacos-sdk-python 3.x gRPC 迁移删除——SDK 内建
+连接保活与断线自动重注册，不再有应用层心跳。
 
 不负责：
 - MQ 消息消费（在主进程中，业务逻辑可能 CPU 密集）
@@ -20,13 +22,10 @@
 import asyncio
 import signal
 import sys
-import threading
-import time
 from multiprocessing.synchronize import Event as EventType
 from typing import Optional
 
 from sycommon.heartbeat_process.heartbeat_config import (
-    NacosHeartbeatConfig,
     RabbitMQMonitorConfig,
     LogConfig
 )
@@ -81,8 +80,7 @@ class HeartbeatProcessWorker:
     """心跳进程工作器 - 在独立进程中运行
 
     职责：
-    1. Nacos 心跳发送（定期向 Nacos 注册中心发送心跳）
-    2. RabbitMQ 连接监控（检查连接存活，发送告警）
+    1. RabbitMQ 连接监控（检查连接存活，发送告警）
 
     不负责：
     - MQ 消息消费（在主进程中，业务逻辑可能 CPU 密集）
@@ -91,7 +89,6 @@ class HeartbeatProcessWorker:
 
     def __init__(
         self,
-        nacos_config: Optional[NacosHeartbeatConfig] = None,
         rabbitmq_config: Optional[RabbitMQMonitorConfig] = None,
         stop_event: Optional[EventType] = None,
         log_config: Optional[LogConfig] = None
@@ -99,32 +96,18 @@ class HeartbeatProcessWorker:
         """初始化心跳进程工作器
 
         Args:
-            nacos_config: Nacos 心跳配置
             rabbitmq_config: RabbitMQ 连接监控配置
             stop_event: 停止信号（multiprocessing.Event）
             log_config: 日志配置（用于初始化 SYLogger）
         """
-        self.nacos_config = nacos_config
         self.rabbitmq_config = rabbitmq_config
         self.stop_event = stop_event
         self.log_config = log_config
 
-        # Nacos 状态
-        self.nacos_client = None
-        self._nacos_heartbeat_thread: Optional[threading.Thread] = None
-        self._nacos_alert_sent = False
-        self._nacos_disconnect_count = 0
-
         # RabbitMQ 监控状态
         self._rabbitmq_alert_sent = False
         self._rabbitmq_disconnect_count = 0
 
-        # 服务信息（用于告警）
-        self._service_name = nacos_config.service_name if nacos_config else None
-        self._service_host = None
-        if nacos_config:
-            self._service_host = f"{nacos_config.real_ip}:{nacos_config.port}"
-
     def run(self):
         """进程入口点
 
@@ -143,17 +126,13 @@ class HeartbeatProcessWorker:
 
         logger.info("心跳进程启动")
 
-        # 3. 初始化并启动 Nacos 心跳
-        if self.nacos_config:
-            if self._init_nacos_client():
-                self._start_nacos_heartbeat_thread()
 
-        # 4. 启动 RabbitMQ 监控（asyncio 事件循环）
+        # 3. 启动 RabbitMQ 监控（asyncio 事件循环）
         if self.rabbitmq_config:
             self._run_rabbitmq_monitor()
         else:
             # 如果没有 RabbitMQ 配置，简单等待停止信号
-            logger.info("未配置 RabbitMQ 监控，仅运行 Nacos 心跳")
+            logger.info("未配置 RabbitMQ 监控，等待停止信号")
             while not self.stop_event.is_set():
                 self.stop_event.wait(timeout=1)
 
@@ -164,184 +143,6 @@ class HeartbeatProcessWorker:
         global logger
         logger.info(f"心跳进程收到信号 {signum}，正在退出...")
 
-    def _init_nacos_client(self) -> bool:
-        """初始化 Nacos 客户端
-
-        Returns:
-            bool: 初始化是否成功
-        """
-        try:
-            import nacos
-            self.nacos_client = nacos.NacosClient(
-                server_addresses=self.nacos_config.server_addresses,
-                namespace=self.nacos_config.namespace_id,
-                username=self.nacos_config.username,
-                password=self.nacos_config.password
-            )
-            # SDK 默认单请求超时仅 3 秒，网络/DNS 抖动即抛
-            # "All server are not available"，放宽到 10 秒
-            self.nacos_client.set_options(default_timeout=10)
-            logger.info("Nacos 客户端初始化成功")
-            return True
-        except Exception as e:
-            logger.error(f"Nacos 客户端初始化失败: {e}")
-            return False
-
-    def _start_nacos_heartbeat_thread(self):
-        """启动 Nacos 心跳线程"""
-        self._nacos_heartbeat_thread = threading.Thread(
-            target=self._nacos_heartbeat_loop,
-            name="NacosHeartbeatThread",
-            daemon=True
-        )
-        self._nacos_heartbeat_thread.start()
-        logger.info("Nacos 心跳线程已启动")
-
-    def _nacos_heartbeat_loop(self):
-        """Nacos 心跳循环
-
-        逻辑与现有的 NacosHeartbeatManager._send_heartbeat_loop() 一致。
-        """
-        consecutive_fail = 0
-        consecutive_success = 0
-
-        logger.info(
-            f"Nacos 心跳循环启动 - "
-            f"服务名: {self.nacos_config.service_name}, "
-            f"间隔: {self.nacos_config.heartbeat_interval}秒"
-        )
-
-        while not self.stop_event.is_set():
-            heartbeat_start_time = time.time()
-
-            try:
-                result = self._send_nacos_heartbeat()
-
-                if result:
-                    consecutive_fail = 0
-                    consecutive_success += 1
-                    logger.info(
-                        f"Nacos 心跳成功，连续成功: {consecutive_success}次"
-                    )
-
-                    # 恢复通知
-                    if self._nacos_alert_sent and consecutive_success >= 1:
-                        self._nacos_alert_sent = False
-                        logger.info("Nacos 心跳已恢复，发送恢复通知")
-                        self._send_nacos_alert_sync(
-                            error_msg="心跳恢复正常",
-                            is_recovered=True,
-                            fail_count=0
-                        )
-                else:
-                    consecutive_success = 0
-                    consecutive_fail += 1
-                    logger.warning(
-                        f"Nacos 心跳失败，连续失败: {consecutive_fail}次"
-                    )
-                    self._handle_nacos_failure(consecutive_fail)
-
-            except Exception as e:
-                consecutive_success = 0
-                consecutive_fail += 1
-                logger.error(f"Nacos 心跳异常: {e}")
-                self._handle_nacos_failure(consecutive_fail)
-
-            # 精确等待
-            elapsed = time.time() - heartbeat_start_time
-            remaining = max(0, self.nacos_config.heartbeat_interval - elapsed)
-            if remaining > 0:
-                self.stop_event.wait(remaining)
-
-        logger.info("Nacos 心跳循环已停止")
-
-    def _send_nacos_heartbeat(self) -> bool:
-        """发送 Nacos 心跳
-
-        Returns:
-            bool: 心跳是否成功
-        """
-        if self.nacos_client is None:
-            logger.warning("Nacos 客户端未初始化")
-            return False
-
-        try:
-            result = self.nacos_client.send_heartbeat(
-                service_name=self.nacos_config.service_name,
-                ip=self.nacos_config.real_ip,
-                port=int(self.nacos_config.port),
-                cluster_name="DEFAULT",
-                weight=1.0,
-                metadata={"version": self.nacos_config.version} if self.nacos_config.version else None
-            )
-
-            if result:
-                logger.debug(f"Nacos 心跳响应: {result}")
-                return True
-            else:
-                logger.warning(f"Nacos 心跳返回空结果")
-                return False
-
-        except Exception as e:
-            logger.error(f"Nacos 心跳发送异常: {e}")
-            return False
-
-    def _handle_nacos_failure(self, consecutive_fail: int):
-        """处理 Nacos 心跳失败
-
-        Args:
-            consecutive_fail: 连续失败次数
-        """
-        # 连续失败 3 次后发送告警（仅发送一次）
-        if consecutive_fail >= 3 and not self._nacos_alert_sent:
-            self._nacos_alert_sent = True
-            self._nacos_disconnect_count += 1
-            logger.warning(
-                f"Nacos 心跳连续失败{consecutive_fail}次，发送告警，"
-                f"累计断开: {self._nacos_disconnect_count}次"
-            )
-            self._send_nacos_alert_sync(
-                error_msg=f"心跳连续失败{consecutive_fail}次",
-                is_recovered=False,
-                fail_count=consecutive_fail
-            )
-
-        # 连续失败 5 次尝试重新初始化客户端
-        if consecutive_fail >= 5:
-            logger.error("Nacos 心跳连续失败5次，尝试重新初始化客户端")
-            self._init_nacos_client()
-
-    def _send_nacos_alert_sync(
-        self,
-        error_msg: str,
-        is_recovered: bool,
-        fail_count: int
-    ):
-        """同步发送 Nacos 告警
-
-        由于告警函数是异步的，需要创建新的事件循环来执行。
-        """
-        try:
-            from sycommon.notice.uvicorn_monitor import send_nacos_disconnect_alert
-
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                loop.run_until_complete(send_nacos_disconnect_alert(
-                    error_msg=error_msg,
-                    service_name=self.nacos_config.service_name,
-                    host=f"{self.nacos_config.real_ip}:{self.nacos_config.port}",
-                    disconnect_count=self._nacos_disconnect_count,
-                    fail_count=fail_count,
-                    is_recovered=is_recovered
-                ))
-            finally:
-                loop.close()
-
-            alert_type = "恢复" if is_recovered else "断开"
-            logger.info(f"Nacos {alert_type}告警发送成功")
-        except Exception as e:
-            logger.error(f"发送 Nacos 告警失败: {e}")
 
     def _run_rabbitmq_monitor(self):
         """运行 RabbitMQ 连接监控（asyncio 事件循环）

{sycommon_python_lib-0.2.10a19 → sycommon_python_lib-0.2.10a20}/src/sycommon/logging/log_masker.py

@@ -53,6 +53,11 @@ _DEFAULTS = {
     "maxListItems": 50,    # list 元素上限，超过则只保留前 N 个 + 摘要
     "headTailKeep": 200,   # 头尾截断时各自保留的字符数
     "dropIfBig": False,    # 整体超过 maxSize 时：False=头尾截断摘要, True=整条丢弃
+    # 文本完整模式（2026-10-26 用户要求）：True 时叶子标量不按 maxLength 折叠、
+    # 超长 list 不摘要——文本类请求/响应体完整落日志；文件类 base64 由
+    # traceid._omit_base64_content 按 content 键省略。字段名脱敏(mask/drop)
+    # 照常；maxSize 整条防线保留（Kafka 单条上限，日志系统自身保护）。
+    "fullText": True,
 }
 
 # 内部哨兵：sanitize 返回它表示「这个 key 应当从父 dict 中删除」
@@ -73,7 +78,7 @@ def _merge(*configs: dict) -> dict:
     list_keys = ("fields", "patterns", "drop", "dropLinePatterns", "maskLinePatterns")
     scalar_keys = (
         "enabled", "maxLength", "maxSize",
-        "maxListItems", "headTailKeep", "dropIfBig",
+        "maxListItems", "headTailKeep", "dropIfBig", "fullText",
     )
 
     acc = {k: set() for k in list_keys}
@@ -179,7 +184,8 @@ class LogMasker(metaclass=SingletonMeta):
 
         return None
 
-    def sanitize_deep_str(self, value: Any, key: Any = None) -> Any:
+    def sanitize_deep_str(self, value: Any, key: Any = None,
+                          full: bool = False) -> Any:
         """深 JSON 字符串脱敏：把整体序列化的大 JSON 逐层展开后按字段裁剪。
 
         背景：traceid 等中间件把 response_body / request_body 传成「整体 JSON
@@ -187,24 +193,30 @@ class LogMasker(metaclass=SingletonMeta):
         ``...[N chars truncated]...``，排障时无法 json.loads 还原，中段字段
         （业务最关心的 data 部分）全部丢失。
 
-        做法：字符串先尝试 json.loads 还原为结构；dict/list 逐层递归（每个
-        叶子标量独立适用 maxLength），无法还原 / 解析失败则回退原字符串走
-        标量截断。递归产物是结构化 dict/list，最终由调用方决定序列化方式——
-        这样即使某个叶子被截断，其余字段仍完整可读。
+        做法：字符串先尝试 json.loads 还原为结构；dict/list 逐层递归，无法
+        还原 / 解析失败则回退原字符串走标量截断。递归产物是结构化 dict/list，
+        最终由调用方决定序列化方式——这样即使某个叶子被截断，其余字段仍完整可读。
+
+        full=True（2026-10-26 用户要求：请求/响应文本完整打印）：叶子不做
+        maxLength 折叠、超长 list 不摘要——文本类内容完整落日志；文件类
+        base64 由调用方（traceid._omit_base64_content）按 content 键省略。
+        字段名脱敏（mask/drop）仍生效；整条防线由 maxSize 兜底（Kafka 单条
+        上限，超限截断是日志系统自身保护，不能去掉）。
 
         仅本地裁剪，不脱字段名（mask/drop 语义不变——命中字段名的值照常
         掩码/删除）。
         """
         if not isinstance(value, str):
-            return self.sanitize(value, key)
+            return self.sanitize(value, key, full=full)
+        no_fold = full or bool(self._config.get("fullText", True))
         try:
             parsed = json.loads(value)
         except (json.JSONDecodeError, ValueError):
-            return self._truncate_str(value)
+            return value if no_fold else self._truncate_str(value)
         if not isinstance(parsed, (dict, list)):
             # "123" / "true" 这类 JSON 标量字符串：还原后反而丢引号语义，按原串截断
-            return self._truncate_str(value)
-        return self._sanitize_value(parsed, key, depth=0)
+            return value if no_fold else self._truncate_str(value)
+        return self._sanitize_value(parsed, key, depth=0, full=full)
 
     def _truncate_str(self, s: str) -> str:
         n = self._config.get("maxLength", 1000)
@@ -216,6 +228,7 @@ class LogMasker(metaclass=SingletonMeta):
         return f"{head}...[{len(s) - 2 * keep} chars truncated]...{tail}"
 
     def _summarize_list(self, items: list, key: Any) -> Any:
+        # 仅 fullText=false 且非 full 时到达(见 _sanitize_value list 分支)
         n = self._config.get("maxListItems", 50)
         # 始终对每个元素递归脱敏（内部大文本值也要按 maxLength 截断）
         if len(items) <= n:
@@ -249,7 +262,10 @@ class LogMasker(metaclass=SingletonMeta):
             value = value.isoformat()
 
         if isinstance(value, str):
-            return value if full else self._truncate_str(value)
+            # fullText 模式(默认开): 文本完整, 不 maxLength 折叠 —
+            # maxSize 整条防线仍兜底; full 参数(SQL 参数路径)语义等价叠加
+            no_fold = full or bool(self._config.get("fullText", True))
+            return value if no_fold else self._truncate_str(value)
         if value is None or isinstance(value, (bool, int, float)):
             return value
 
@@ -267,10 +283,11 @@ class LogMasker(metaclass=SingletonMeta):
                 out[k] = sv
             return out
 
-        # 5. list：full 不摘要逐项递归；否则超长摘要
+        # 5. list：full/不摘要时逐项递归；否则超长摘要
         if isinstance(value, (list, tuple)):
             items = list(value)
-            if full:
+            no_sum = full or bool(self._config.get("fullText", True))
+            if no_sum:
                 return [self._sanitize_value(v, _child_key(key, i), depth + 1,
                                              full=full)
                         for i, v in enumerate(items)]

{sycommon_python_lib-0.2.10a19 → sycommon_python_lib-0.2.10a20}/src/sycommon/middleware/traceid.py

@@ -111,15 +111,34 @@ def _gateway_user_ctx(request) -> list:
     return out
 
 
+# base64/二进制启发式：长串且几乎全是 base64 字符集（无空格/换行/中文/标点）。
+# 纯文本（分析报告、SQL、代码）必然含空格或 base64 字符集之外的字符，不会误伤。
+_B64ISH_RE = re.compile(r"^[A-Za-z0-9+/=\s]{200,}$")
+
+
+def _looks_like_base64(s: str) -> bool:
+    """判定超长字符串是否疑似 base64/二进制转写（PDF/图片等）。
+
+    用户要求（2026-10-26）：只有文件类 base64 省略，长【文本】完整打印。
+    启发式：长度>1000 且去除空白后全部落在 base64 字符集内。普通长文本
+    含空格/标点/中文，天然不满足。
+    """
+    if len(s) <= 1000:
+        return False
+    compact = "".join(s.split())
+    return bool(_B64ISH_RE.match(compact))
+
+
 def _omit_base64_content(obj: Any) -> None:
-    """把结构化响应体里超长的 content 值（PDF/图片 base64）替换为省略占位。
+    """把结构化响应体里疑似 base64 的超长 content 值替换为省略占位。
 
     就地修改，dict/list 逐层递归。sanitize_deep_str 已把 JSON 字符串还原成
     结构化 dict/list——不能再 json.loads（传容器进去会 TypeError）。
+    只省略「疑似 base64/二进制」；长纯文本完整保留（_looks_like_base64）。
     """
     if isinstance(obj, dict):
         c = obj.get("content")
-        if c and len(str(c)) > 1000:
+        if c and _looks_like_base64(str(c)):
             obj["content"] = f"... (base64/binary content omitted, {len(str(c))} chars)"
     elif isinstance(obj, list):
         for item in obj: