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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.10a19
+Version: 0.2.10a21
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -14,17 +14,17 @@ Requires-Dist: elasticsearch==9.5.1
 Requires-Dist: fastapi==0.143.0
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: kafka-python==3.0.11
-Requires-Dist: langchain==1.4.6
-Requires-Dist: langchain-core==1.6.12
-Requires-Dist: langchain-openai==1.7.2
-Requires-Dist: langfuse==5.0.2
-Requires-Dist: langgraph==1.2.16
+Requires-Dist: langchain==1.4.7
+Requires-Dist: langchain-core==1.7.0
+Requires-Dist: langchain-openai==1.7.3
+Requires-Dist: langfuse==5.0.4
+Requires-Dist: langgraph==1.2.18
 Requires-Dist: langgraph-checkpoint-postgres==3.2.0
 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: mysql-connector-python==26.10.0
+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.10a21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.10a19"
+version = "0.2.10a21"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -15,17 +15,17 @@ dependencies = [
     "fastapi==0.143.0",
     "jinja2==3.1.6",
     "kafka-python==3.0.11",
-    "langchain==1.4.6", 
-    "langchain-core==1.6.12",
-    "langchain-openai==1.7.2",
-    "langfuse==5.0.2",
-    "langgraph==1.2.16",
+    "langchain==1.4.7", 
+    "langchain-core==1.7.0",
+    "langchain-openai==1.7.3",
+    "langfuse==5.0.4",
+    "langgraph==1.2.18",
     "langgraph-checkpoint-postgres==3.2.0",
     "langgraph-checkpoint-redis==0.5.2",
     "ldap3==2.9.1",
     "loguru==0.7.3",
-    "mysql-connector-python==26.7.0",
-    "nacos-sdk-python==2.0.11,<3.0",
+    "mysql-connector-python==26.10.0",
+    "nacos-sdk-python==3.2.0",
     "psutil==7.2.2",
     "pyxxl==0.4.8",
     "pydantic==2.14.1",
@@ -60,8 +60,15 @@ build-backend = "setuptools.build_meta"
 [dependency-groups]
 dev = [
     "pytest>=9.0.3",
+    "pytest-asyncio>=1.3.0",
 ]
 
+# asyncio_mode=auto：src/sycommon/tests 内的 async 测试（如
+# test_consumer_loss_rootcause.py）无 @pytest.mark.asyncio 标记，
+# STRICT 模式下直接报 "not natively supported"（2026-10-28 实测）。
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
 [project.scripts]
 sycommon = "command.cli:main"
 sycli = "sycli.cli:main"

sycommon_python_lib-0.2.10a21/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.10a21}/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.10a21}/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.10a21}/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.10a21}/src/sycommon/logging/kafka_log.py

@@ -481,7 +481,12 @@ class KafkaSink:
             # 与 trace/tenant 正文兜底共用,避免二次 json.loads。
             msg_obj = None
             try:
-                _parsed = json.loads(record["message"])
+                # 🔴 ERROR 事件(str(message) 含 opt(exception=) 渲染的堆栈正文,
+                # 追加在 JSON 之后)整串 json.loads 会炸 "Extra data"——信封解析
+                # 全盘失效(ERROR 降级 INFO/丢 detail 的 2026-10-28 回归根因)。
+                # raw_decode 只取头部第一个完整 JSON 对象,尾部堆栈文本忽略
+                # (堆栈已由信封 detail 键携带,record.exception 在队列路径恒 None)。
+                _parsed = json.JSONDecoder().raw_decode(record["message"])[0]
                 # 🔑 哨兵判定:仅 _log 信封(_sy_log_envelope=True)才解包;
                 # 业务方传 JSON dict(即便含 message/trace_id 键)不当作信封
                 # —— msg 原样透传整包 dict JSON,trace/tenant 不误读。
@@ -644,7 +649,14 @@ class KafkaSink:
                 "reqSource": req_source,
                 "serviceId": self.service_id,
                 "logType": "biz",
-                "logLevel": record["level"].name,
+                # 队列路径(_StrWithRecord 空 record)level.name 恒兜底 "INFO"
+                # —— ERROR 会被错标 INFO(平台按级别过滤时全部漏掉)。
+                # 信封正文 level 键兜底(_log/excepthook 路径都写)。
+                "logLevel": (
+                    msg_obj.get("level")
+                    if msg_obj is not None and msg_obj.get("level")
+                    else record["level"].name
+                ),
                 "className": class_name,
                 "classShortName": _class_short,
                 "method": caller_fn or record["function"],
@@ -863,7 +875,32 @@ class _InterceptHandler(logging.Handler):
             frame = frame.f_back
             depth += 1
 
-        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
+        # 🔴 2026-10-28 残留闭合:裸文本经 BoundedKafkaSink 队列 str 化后
+        # level 恒兜底 INFO、exception 堆栈丢失(asyncio 兜底链 "Task
+        # exception was never retrieved" 即此路径)。包成 _sy_log_envelope
+        # 信封,write() 消费侧按哨兵解包回 level/detail/_threadName —— 与
+        # SYLogger._log / 三个 excepthook 发射器同款双通道机制。
+        # trace_id 不塞:留空走 write() 的 contextvar→Snowflake 既有兜底。
+        if not isinstance(level, str):
+            level = logging.getLevelName(record.levelno) or "INFO"
+        envelope: dict = {
+            "message": record.getMessage(),
+            "level": level,
+            "_sy_log_envelope": True,
+        }
+        if record.threadName:
+            envelope["_threadName"] = f"thread:{record.threadName}"
+        if record.exc_info and record.exc_info[0] is not None:
+            envelope["detail"] = "".join(
+                traceback.format_exception(*record.exc_info))
+        # opt(exception=...) 保留:stdout ERROR sink 仍靠它渲染彩色堆栈;
+        # 队列路径 str(message) 会在 JSON 后追加渲染文本,write() 的
+        # raw_decode 只取头部 JSON,尾部忽略(同 _log 路径)。
+        # stdout 侧可读性:JSON 信封一整行 + 下方渲染堆栈 —— 与 SYLogger._log
+        # 在生产 stdout 的既有形态一致(log_json 同样整行落 message),不引入
+        # 新的显示形态分歧。
+        logger.opt(depth=depth, exception=record.exc_info).log(
+            level, json.dumps(envelope, ensure_ascii=False))
 
 
 class KafkaLogger(metaclass=SingletonMeta):
@@ -1033,6 +1070,7 @@ class KafkaLogger(metaclass=SingletonMeta):
             "message": f"asyncio unhandled: {message}",
             "level": "ERROR",
             "detail": tb_str,
+            "_sy_log_envelope": True,
         }, ensure_ascii=False)
 
         logger.opt(exception=True).error(error_msg)
@@ -1047,7 +1085,8 @@ class KafkaLogger(metaclass=SingletonMeta):
         error_msg = json.dumps({
             "trace_id": trace_id,
             "message": f"Uncaught exception: {exc_type.__name__}",
-            "level": "ERROR"
+            "level": "ERROR",
+            "_sy_log_envelope": True,
         }, ensure_ascii=False)
 
         logger.opt(exception=(exc_type, exc_value,
@@ -1071,6 +1110,7 @@ class KafkaLogger(metaclass=SingletonMeta):
             "level": "ERROR",
             "detail": "".join(traceback.format_exception(
                 args.exc_type, args.exc_value, args.exc_traceback)),
+            "_sy_log_envelope": True,
         }, ensure_ascii=False)
 
         logger.opt(exception=(args.exc_type, args.exc_value,