sycommon-python-lib 0.2.6a12__tar.gz → 0.2.6a14__tar.gz

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.6a12
+Version: 0.2.6a14
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -11,7 +11,7 @@ Requires-Dist: anyio==4.13.0
 Requires-Dist: decorator==5.3.1
 Requires-Dist: deepagents==0.6.10
 Requires-Dist: elasticsearch==9.4.1
-Requires-Dist: fastapi==0.136.3
+Requires-Dist: fastapi==0.137.0
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: kafka-python==3.0.0
 Requires-Dist: langchain==1.3.9

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.6a12"
+version = "0.2.6a14"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -12,7 +12,7 @@ dependencies = [
     "decorator==5.3.1",
     "deepagents==0.6.10",
     "elasticsearch==9.4.1",
-    "fastapi==0.136.3",
+    "fastapi==0.137.0",
     "jinja2==3.1.6",
     "kafka-python==3.0.0",
     "langchain==1.3.9",

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/agent/sandbox/minio_sync.py

@@ -63,10 +63,23 @@ class MinioSyncService(metaclass=SingletonMeta):
             instance._initialized = True
             SYLogger.info(
                 f"[MinIO] Client initialized: {cfg['endpoint']}, bucket={instance._bucket}")
+
+            # 订阅配置热更新（幂等）
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("minio_sync", sync_cb=cls.reload)
         except Exception as e:
             SYLogger.error(f"[MinIO] Client initialization failed: {e}")
             instance._initialized = False
 
+    @classmethod
+    def reload(cls) -> None:
+        """配置热更新：清空旧 client 并按最新配置重建（setup 幂等 guard 需先置 None）。"""
+        instance = cls()
+        instance._initialized = None
+        instance._client = None
+        instance._bucket = None
+        cls.setup()
+
     def _load_config(self, config: dict = None) -> dict:
         """从 Nacos 配置或环境变量加载 MinIO 配置"""
         if config:

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/auth/wecom_ldap_service.py

@@ -211,6 +211,10 @@ class WeComLDAPService(metaclass=SingletonMeta):
         # 企微部门 ID -> 名称 缓存
         self._dept_map: Dict[int, str] = {}
 
+        # 订阅配置热更新（幂等）
+        from sycommon.config.config_change_notifier import notifier
+        notifier.register("wecom_ldap", sync_cb=self.reload)
+
     def _ensure_configs(self):
         """延迟加载配置"""
         if self._wecom_config is None:
@@ -220,6 +224,15 @@ class WeComLDAPService(metaclass=SingletonMeta):
 
             self._ldap_config = LDAPConfig.from_config()
 
+    def reload(self) -> None:
+        """配置热更新：清空缓存的 WeCom/LDAP 配置及派生缓存，下次使用重新读取。"""
+        self._wecom_config = None
+        self._ldap_config = None
+        # 派生缓存（token/index/dept）按 TTL 自然过期即可，无需立即清；
+        # access_token 直接作废，避免用旧 secret 换来的 token 继续生效。
+        self._access_token = None
+        self._token_expires_at = 0
+
     # ─── 企微 API ───
 
     async def _get_access_token(self) -> str:

sycommon_python_lib-0.2.6a14/src/sycommon/config/config_change_notifier.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+"""配置变更通知器（事件总线）
+
+当 Nacos 共享配置发生变更时，NacosConfigManager._sync_to_global_config() 会先
+把最新配置合并进全局 Config 单例，然后调用 notifier.fire() 通知所有订阅者。
+
+设计要点：
+    - 解耦：nacos_config_manager 不直接 import 各业务单例，各单例在自己
+      init/setup 成功后调 register() 订阅自己的 reload()。
+    - 去抖：Nacos watcher 按 dataId 独立触发，短时间内多个 dataId 连续变更
+      （或同一 dataId 抖动）会被合并成一次 fan-out，避免重复 rebuild。
+      去抖窗口默认 500ms，用 threading.Timer 实现（watcher 回调跑在 Nacos
+      SDK 线程，不在 asyncio loop 里，不能用 asyncio 定时器）。
+    - sync / async 混合回调：
+        * sync_cb 直接 inline 执行。
+        * async_cb 通过 asyncio.run_coroutine_threadsafe 投递到 Services
+          捕获的主事件循环（见 Services._init_event_loop 调用 set_loop）。
+          无可用 loop 时跳过并告警（本地 dev 模式不会触发 fire，仅兜底）。
+    - 错误隔离：任一回调抛异常只记录日志，不影响其他回调，也不会冒泡
+      到 Nacos SDK 线程导致后续 watcher 失效。
+
+典型用法（业务单例内部）：
+
+    from sycommon.config.config_change_notifier import notifier
+
+    class RedisService:
+        @classmethod
+        async def reload(cls):
+            ...
+
+        @classmethod
+        def init(cls, ...):
+            ...
+            notifier.register("redis", async_cb=cls.reload)
+"""
+import asyncio
+import threading
+from typing import Awaitable, Callable, Dict, Optional, Tuple
+
+from sycommon.logging.kafka_log import SYLogger
+
+# 默认去抖窗口（秒）：Nacos 多个 dataId 连续变更时合并为一次 reload
+_DEFAULT_DEBOUNCE_SECONDS = 0.5
+
+# 同步/异步回调签名
+SyncCB = Callable[[], None]
+AsyncCB = Callable[[], Awaitable[None]]
+
+
+class ConfigChangeNotifier:
+    """配置变更事件总线（模块级单例 ``notifier``）"""
+
+    def __init__(self, debounce_seconds: float = _DEFAULT_DEBOUNCE_SECONDS):
+        self._debounce_seconds = debounce_seconds
+        # name -> (sync_cb, async_cb)
+        self._callbacks: Dict[str, Tuple[Optional[SyncCB], Optional[AsyncCB]]] = {}
+        self._lock = threading.Lock()
+        # 待触发的去抖定时器
+        self._timer: Optional[threading.Timer] = None
+        # 业务主事件循环（由 Services._init_event_loop 注入），
+        # 用于把 async reload 投递回业务线程。
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+
+    # ------------------------------------------------------------------ 注册
+    def register(
+        self,
+        name: str,
+        sync_cb: Optional[SyncCB] = None,
+        async_cb: Optional[AsyncCB] = None,
+    ) -> None:
+        """注册一个 reload 回调（幂等：同名重复注册覆盖上一次）。
+
+        Args:
+            name: 订阅者唯一标识，建议用单例类名/服务名。
+            sync_cb: 同步 reload 函数，在 fan-out 时 inline 执行。
+            async_cb: 异步 reload 函数，通过 run_coroutine_threadsafe 投递。
+            两者至少传一个。
+        """
+        if sync_cb is None and async_cb is None:
+            return
+        with self._lock:
+            self._callbacks[name] = (sync_cb, async_cb)
+
+    def unregister(self, name: str) -> None:
+        """取消订阅。"""
+        with self._lock:
+            self._callbacks.pop(name, None)
+
+    def set_loop(self, loop: Optional[asyncio.AbstractEventLoop]) -> None:
+        """注入业务主事件循环，供 async 回调投递。"""
+        self._loop = loop
+
+    # ------------------------------------------------------------------ 触发
+    def fire(self) -> None:
+        """通知一次配置变更（去抖：窗口内多次调用合并为一次 fan-out）。"""
+        with self._lock:
+            if self._timer is not None:
+                # 已有待触发的定时器：取消并重置，相当于「滑动窗口续期」
+                self._timer.cancel()
+                self._timer = None
+            timer = threading.Timer(self._debounce_seconds, self._fan_out)
+            timer.daemon = True
+            timer.start()
+            self._timer = timer
+
+    def reload_now(self) -> None:
+        """立即触发一次 fan-out（取消挂起的去抖定时器）。供测试/手动触发。"""
+        with self._lock:
+            if self._timer is not None:
+                self._timer.cancel()
+                self._timer = None
+        self._fan_out()
+
+    def _fan_out(self) -> None:
+        """执行所有已注册回调。每个回调独立 try/except，互不影响。"""
+        # 快照一份，执行期间新的 register 不影响本轮
+        items = list(self._callbacks.items())
+        loop = self._loop
+
+        for name, (sync_cb, async_cb) in items:
+            if sync_cb is not None:
+                try:
+                    sync_cb()
+                except Exception as e:  # noqa: BLE001 - 通知器不能让单点故障扩散
+                    SYLogger.error(
+                        f"config_change_notifier: 同步 reload 失败 [{name}]: {e}",
+                        exc_info=True,
+                    )
+            if async_cb is not None:
+                self._schedule_async(name, async_cb, loop)
+
+    def _schedule_async(
+        self,
+        name: str,
+        async_cb: AsyncCB,
+        loop: Optional[asyncio.AbstractEventLoop],
+    ) -> None:
+        """把 async 回调投递到业务事件循环。无 loop 则告警跳过。"""
+        if loop is None:
+            # 兜底：尝试取当前线程的 loop（极少命中，watcher 在 SDK 线程）
+            try:
+                loop = asyncio.get_event_loop()
+            except RuntimeError:
+                loop = None
+        if loop is None or loop.is_closed():
+            SYLogger.warning(
+                f"config_change_notifier: 无可用事件循环，跳过异步 reload [{name}]"
+            )
+            return
+        try:
+            future = asyncio.run_coroutine_threadsafe(async_cb(), loop)
+
+            def _on_done(fut):
+                try:
+                    fut.result()
+                except Exception as e:  # noqa: BLE001
+                    SYLogger.error(
+                        f"config_change_notifier: 异步 reload 失败 [{name}]: {e}",
+                        exc_info=True,
+                    )
+
+            future.add_done_callback(_on_done)
+        except Exception as e:  # noqa: BLE001
+            SYLogger.error(
+                f"config_change_notifier: 投递异步 reload 失败 [{name}]: {e}",
+                exc_info=True,
+            )
+
+
+# 模块级单例
+notifier = ConfigChangeNotifier()

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/database/async_database_service.py

@@ -10,6 +10,8 @@ from sycommon.synacos.nacos_service import NacosService
 
 class AsyncDatabaseService(metaclass=SingletonMeta):
     _engine = None
+    # setup 时记录入参，供 reload() 重建使用
+    _setup_args = None
 
     @staticmethod
     async def setup_database(config: dict, shareConfigKey: str):
@@ -29,10 +31,49 @@ class AsyncDatabaseService(metaclass=SingletonMeta):
             if not await connector.test_connection():
                 raise Exception("Database connection test failed")
 
+            # 记录入参，供热更新 reload 使用
+            AsyncDatabaseService._setup_args = (config, shareConfigKey)
+            # 订阅配置热更新（幂等）
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("async_database", async_cb=AsyncDatabaseService.reload)
+
     @staticmethod
     def engine():
         return AsyncDatabaseService._engine
 
+    @staticmethod
+    async def dispose() -> None:
+        """释放异步引擎连接池资源"""
+        if AsyncDatabaseService._engine is not None:
+            try:
+                await AsyncDatabaseService._engine.dispose()
+            except Exception as e:
+                SYLogger.error(f"AsyncDatabase engine dispose error: {e}")
+            finally:
+                AsyncDatabaseService._engine = None
+
+    @classmethod
+    async def reload(cls) -> None:
+        """配置热更新：dispose 旧引擎并按最新配置重建，失败回退。"""
+        if not cls._setup_args:
+            return
+        old_engine = cls._engine
+        # 清掉 AsyncDatabaseConnector 单例缓存，使其按新配置重建
+        from sycommon.config.Config import SingletonMeta
+        SingletonMeta._instances.pop(AsyncDatabaseConnector, None)
+        try:
+            await cls.setup_database(*cls._setup_args)
+        except Exception as e:
+            SYLogger.error(f"AsyncDatabaseService reload 重建失败: {e}", exc_info=True)
+            cls._engine = old_engine
+            return
+        # 新 engine 建好，释放旧的
+        if old_engine is not None:
+            try:
+                await old_engine.dispose()
+            except Exception as e:
+                SYLogger.error(f"AsyncDatabaseService reload 释放旧 engine 失败: {e}")
+
 
 class AsyncDatabaseConnector(metaclass=SingletonMeta):
     def __init__(self, db_config: DatabaseConfig):

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/database/database_service.py

@@ -9,6 +9,8 @@ from sycommon.synacos.nacos_service import NacosService
 
 class DatabaseService(metaclass=SingletonMeta):
     _engine = None
+    # setup 时记录入参，供 reload() 重建使用（config + shareConfigKey）
+    _setup_args = None
 
     @staticmethod
     def setup_database(config: dict, shareConfigKey: str):
@@ -18,6 +20,11 @@ class DatabaseService(metaclass=SingletonMeta):
             converted_dict = convert_dict_keys(databaseConfig)
             db_config = DatabaseConfig.model_validate(converted_dict)
             DatabaseService._engine = DatabaseConnector(db_config).engine
+            # 记录入参，供热更新 reload 使用
+            DatabaseService._setup_args = (config, shareConfigKey)
+            # 订阅配置热更新（幂等）
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("database", sync_cb=DatabaseService.reload)
 
     @staticmethod
     def engine():
@@ -35,6 +42,35 @@ class DatabaseService(metaclass=SingletonMeta):
             finally:
                 DatabaseService._engine = None
 
+    @staticmethod
+    def reload() -> None:
+        """配置热更新：用最新 datasource 重建 engine，失败回退旧 engine。
+
+        注意：已存在的 BaseDBService 子类实例在 __init__ 缓存了旧 engine 的
+        sessionmaker，热切换后长期持有的实例需重新构造；通常业务侧每次请求
+        new 出来，影响有限。
+        """
+        if not DatabaseService._setup_args:
+            return
+        old_engine = DatabaseService._engine
+        DatabaseService._engine = None
+        # 清掉 DatabaseConnector 单例缓存，使其按新配置重建
+        from sycommon.config.Config import SingletonMeta
+        from sycommon.database.database_service import DatabaseConnector
+        SingletonMeta._instances.pop(DatabaseConnector, None)
+        try:
+            DatabaseService.setup_database(*DatabaseService._setup_args)
+        except Exception as e:
+            SYLogger.error(f"DatabaseService reload 重建失败: {e}", exc_info=True)
+            DatabaseService._engine = old_engine
+            return
+        # 新 engine 建好，释放旧的
+        if old_engine is not None:
+            try:
+                old_engine.dispose()
+            except Exception as e:
+                SYLogger.error(f"DatabaseService reload 释放旧 engine 失败: {e}")
+
 
 class DatabaseConnector(metaclass=SingletonMeta):
     def __init__(self, db_config: DatabaseConfig):

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/database/elasticsearch_service.py

@@ -72,6 +72,10 @@ class ElasticsearchService(metaclass=SingletonMeta):
             cls._initialized = True
             logging.info(f"ElasticsearchService 初始化成功，ES 地址: {es_config.uris}")
 
+            # 订阅配置热更新（幂等）
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("elasticsearch", async_cb=cls.reload)
+
         except Exception as e:
             logging.error(f"ElasticsearchService 初始化失败: {e}", exc_info=True)
 
@@ -102,3 +106,26 @@ class ElasticsearchService(metaclass=SingletonMeta):
             finally:
                 cls._client = None
                 cls._initialized = False
+
+    @classmethod
+    async def reload(cls) -> None:
+        """配置热更新：用最新 ElasticsearchConfig 重建 client，失败回退旧 client。"""
+        old_client = cls._client
+        cls._client = None
+        cls._initialized = False
+        try:
+            cls.init()
+        except Exception as e:
+            logging.error(f"ElasticsearchService reload 重建失败: {e}", exc_info=True)
+        if cls._initialized:
+            # 新 client 已就绪，关闭旧的
+            if old_client is not None:
+                try:
+                    await old_client.close()
+                except Exception as e:
+                    logging.debug(f"reload 关闭旧 ES 连接失败: {e}")
+        else:
+            # 重建未成功（如配置缺失），回退到旧 client
+            logging.warning("ElasticsearchService reload 未成功，保留旧 ES 连接")
+            cls._client = old_client
+            cls._initialized = old_client is not None

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/database/pg_checkpoint_service.py

@@ -103,6 +103,10 @@ class PgCheckpointService(metaclass=SingletonMeta):
                 f"PgCheckpointService 初始化成功，地址: {cls._config.host}:{cls._config.port}/{cls._config.dbname}"
             )
 
+            # 订阅配置热更新（幂等）
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("pg_checkpoint", async_cb=cls.reload)
+
         except Exception as e:
             logging.error(f"PgCheckpointService 初始化失败: {e}", exc_info=True)
             # 清理可能已创建的连接池
@@ -150,3 +154,24 @@ class PgCheckpointService(metaclass=SingletonMeta):
                 cls._pool = None
                 cls._checkpointer = None
                 cls._initialized = False
+
+    @classmethod
+    async def reload(cls) -> None:
+        """配置热更新：关闭旧连接池并按最新 llm.PostgreSQL 重建。
+
+        关键：close() 不重置 _setup_attempts，而 setup() 在达到 _max_setup_attempts
+        时会拒绝重建，所以这里必须手动重置计数器。
+        """
+        if not cls._initialized:
+            return
+        try:
+            await cls.close()
+        except Exception as e:
+            logging.error(f"PgCheckpointService reload close 失败: {e}", exc_info=True)
+        # 重置重试计数器，允许重新 setup
+        cls._setup_attempts = 0
+        cls._initialized = False
+        try:
+            await cls.setup()
+        except Exception as e:
+            logging.error(f"PgCheckpointService reload 重建失败: {e}", exc_info=True)

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/database/redis_service.py

@@ -85,6 +85,10 @@ class RedisService(metaclass=SingletonMeta):
 
             cls._initialized = True
 
+            # 订阅配置热更新（幂等）：redis.yml 变更后重建连接
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("redis", async_cb=cls.reload)
+
         except Exception as e:
             logging.error(f"RedisService 初始化失败: {e}", exc_info=True)
 
@@ -765,3 +769,20 @@ class RedisService(metaclass=SingletonMeta):
     def is_initialized(cls) -> bool:
         """检查是否已初始化"""
         return cls._initialized
+
+    @classmethod
+    async def reload(cls) -> None:
+        """配置热更新：关闭旧连接并按最新 redis.yml 重建。
+
+        重建失败（如新配置缺失/错误）时，旧连接已关闭无法回退，
+        会落入未初始化状态并记录日志。Redis 配置通常稳定，可接受。
+        """
+        if not cls._initialized:
+            # 尚未初始化：无需 reload，等首次 init 读最新配置即可
+            return
+        try:
+            await cls.close()
+        except Exception as e:
+            logging.error(f"RedisService reload 关闭旧连接失败: {e}", exc_info=True)
+        # close() 已将 _initialized 置 False；init() 不传 config 会自动读最新 redis.yml
+        cls.init()

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/database/token_usage_db_service.py

@@ -76,6 +76,11 @@ class TokenUsageDBService(metaclass=SingletonMeta):
 
             cls._initialized = True
             logging.info("TokenUsageDBService 初始化成功")
+
+            # 订阅配置热更新（幂等）
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("token_usage_db", async_cb=cls.reload)
+
             return True
 
         except Exception as e:
@@ -117,6 +122,43 @@ class TokenUsageDBService(metaclass=SingletonMeta):
         """检查是否已初始化"""
         return cls._initialized
 
+    @classmethod
+    async def dispose(cls) -> None:
+        """释放异步引擎连接池资源"""
+        if cls._engine is not None:
+            try:
+                await cls._engine.dispose()
+            except Exception as e:
+                logging.error(f"TokenUsageDBService dispose error: {e}")
+            finally:
+                cls._engine = None
+                cls._session_factory = None
+                cls._initialized = False
+
+    @classmethod
+    async def reload(cls) -> None:
+        """配置热更新：dispose 旧引擎并按最新 llm.spring.datasource 重建。
+
+        新配置缺失时落入未初始化状态（Token 记录功能禁用）。
+        """
+        old_engine = cls._engine
+        try:
+            await cls.dispose()
+        except Exception as e:
+            logging.error(f"TokenUsageDBService reload dispose 失败: {e}", exc_info=True)
+        # init() 不传参，自动读最新 Config().config["llm"].spring.datasource
+        try:
+            ok = cls.init()
+        except Exception as e:
+            logging.error(f"TokenUsageDBService reload 重建失败: {e}", exc_info=True)
+            ok = False
+        if not ok:
+            if old_engine is not None:
+                logging.warning("TokenUsageDBService reload 未成功，保留旧 engine")
+                cls._engine = old_engine
+            else:
+                logging.warning("TokenUsageDBService reload 失败，Token 记录功能将禁用")
+
 
 class TokenUsageDBConnector(metaclass=SingletonMeta):
     """Token 使用量数据库连接器"""

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/llm/embedding.py

@@ -42,6 +42,21 @@ class Embedding(metaclass=SingletonMeta):
 
         atexit.register(self._sync_close_session)
 
+        # 订阅配置热更新（幂等）：清空模型 URL 缓存，下次请求重新从最新配置读取。
+        # 不动 self.session：aiohttp session 是共享传输层，与配置无关。
+        from sycommon.config.config_change_notifier import notifier
+        notifier.register("embedding", sync_cb=self.reload)
+
+    def reload(self) -> None:
+        """配置热更新：清空模型 URL 缓存。
+
+        仅清缓存，不重建 aiohttp session（session 与配置无关，重建反而有成本）。
+        下次请求 _get_embedding_url/_get_reranker_url 会按最新配置重新填充。
+        """
+        with self._url_lock:
+            self._embedding_url_cache.clear()
+            self._reranker_url_cache.clear()
+
     def _get_loop_limiter(self):
         """获取当前 Loop 的原生 Semaphore"""
         loop = asyncio.get_running_loop()

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/llm/llm_logger.py

@@ -4,6 +4,7 @@ from langchain_core.outputs import GenerationChunk, ChatGeneration
 from langchain_core.messages import BaseMessage
 
 from sycommon.logging.kafka_log import SYLogger
+from sycommon.logging.log_masker import masker as _log_masker
 
 
 class LLMLogger(AsyncCallbackHandler):
@@ -63,15 +64,19 @@ class LLMLogger(AsyncCallbackHandler):
     def _log_prompts(self, prompts: List[str]) -> None:
         """记录提示词"""
         for i, prompt in enumerate(prompts):
-            SYLogger.info(f"提示词 #{i+1}:\n{prompt}")
+            # 用 sanitize 而非 mask_string：遵循 maxLength 做单值截断
+            # （mask_string 只在整条超 maxSize 时才动，会把 27KB 的 system prompt 原样落盘）
+            SYLogger.info(f"提示词 #{i+1}:\n{_log_masker.sanitize(prompt)}")
 
     def _log_chat_messages(self, messages: List[List[BaseMessage]]) -> None:
         """记录聊天模型的消息"""
         for i, message_group in enumerate(messages):
             SYLogger.info(f"消息组 #{i+1}:")
             for msg in message_group:
-                SYLogger.info(f"  {msg.type}: {msg.content}")
+                # content 可能是 str，也可能是 LangChain 多模态的 list[dict]
+                # sanitize 会按 maxLength 截断内部的大文本值
+                SYLogger.info(f"  {msg.type}: {_log_masker.sanitize(msg.content)}")
 
     def _log_result(self, result: str, index: int) -> None:
         """记录结果"""
-        SYLogger.info(f"结果 #{index}:\n{result}")
+        SYLogger.info(f"结果 #{index}:\n{_log_masker.sanitize(result)}")

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/llm/sy_langfuse.py

@@ -34,6 +34,12 @@ class LangfuseInitializer(metaclass=SingletonMeta):
 
         # 执行初始化
         self._initialize()
+        # 订阅配置热更新（幂等）
+        self._register_hot_reload()
+
+    def _register_hot_reload(self):
+        from sycommon.config.config_change_notifier import notifier
+        notifier.register("langfuse", sync_cb=self.reload)
 
     def _initialize(self):
         """执行实际的配置读取和组件创建"""
@@ -113,6 +119,20 @@ class LangfuseInitializer(metaclass=SingletonMeta):
         """获取 Langfuse 组件"""
         return list(self._base_callbacks), self._langfuse_client
 
+    def reload(self) -> None:
+        """配置热更新：重建 Langfuse client 与回调。
+
+        Langfuse SDK 的 get_client() 返回全局 client，环境变量变更后重建幂等。
+        _initialize() 内部已 try/except，失败不会抛出。
+        """
+        try:
+            self._base_callbacks = []
+            self._langfuse_client = None
+            self._initialize()
+            SYLogger.info("Langfuse 配置热更新完成")
+        except Exception as e:
+            SYLogger.error(f"Langfuse 配置热更新失败: {str(e)}", exc_info=True)
+
     @staticmethod
     def get() -> Tuple[List[Any], Optional[Langfuse]]:
         """一句话获取组件"""

{sycommon_python_lib-0.2.6a12 → sycommon_python_lib-0.2.6a14}/src/sycommon/logging/async_sql_logger.py

@@ -1,9 +1,7 @@
 from sqlalchemy import event
-from sqlalchemy.ext.asyncio import AsyncEngine
 from sycommon.logging.kafka_log import SYLogger
+from sycommon.logging.log_masker import masker as _log_masker
 import time
-from datetime import datetime
-from decimal import Decimal
 
 
 class AsyncSQLTraceLogger:
@@ -13,23 +11,13 @@ class AsyncSQLTraceLogger:
         为 SQLAlchemy 异步引擎注册事件监听器
         注意：必须监听 engine.sync_engine，而不能直接监听 AsyncEngine
         """
-        def serialize_params(params):
-            """处理特殊类型参数的序列化"""
-            if isinstance(params, (list, tuple)):
-                return [serialize_params(p) for p in params]
-            elif isinstance(params, dict):
-                return {k: serialize_params(v) for k, v in params.items()}
-            elif isinstance(params, datetime):
-                return params.isoformat()
-            elif isinstance(params, Decimal):
-                return float(params)
-            else:
-                return params
-
         # ========== 核心修改 ==========
         # 必须通过 engine.sync_engine 来获取底层的同步引擎进行监听
         target = engine.sync_engine
 
+        # 参数序列化（含脱敏/裁剪）统一走 LogMasker，避免与同步实现重复
+        serialize_params = _log_masker.serialize_params
+
         @event.listens_for(target, "after_cursor_execute")
         def after_cursor_execute(
             conn, cursor, statement, parameters, context, executemany