sycommon-python-lib 0.2.7a1__tar.gz → 0.2.7a3__tar.gz

{sycommon_python_lib-0.2.7a1 → sycommon_python_lib-0.2.7a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.7a1
+Version: 0.2.7a3
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -14,9 +14,9 @@ Requires-Dist: elasticsearch==9.4.1
 Requires-Dist: fastapi==0.138.0
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: kafka-python==3.0.2
-Requires-Dist: langchain==1.3.10
+Requires-Dist: langchain==1.3.11
 Requires-Dist: langchain-core==1.4.8
-Requires-Dist: langchain-openai==1.3.2
+Requires-Dist: langchain-openai==1.3.3
 Requires-Dist: langfuse==4.9.1
 Requires-Dist: langgraph==1.2.6
 Requires-Dist: langgraph-checkpoint-postgres==3.1.0

{sycommon_python_lib-0.2.7a1 → sycommon_python_lib-0.2.7a3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.7a1"
+version = "0.2.7a3"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -15,9 +15,9 @@ dependencies = [
     "fastapi==0.138.0",
     "jinja2==3.1.6",
     "kafka-python==3.0.2",
-    "langchain==1.3.10",
+    "langchain==1.3.11",
     "langchain-core==1.4.8",
-    "langchain-openai==1.3.2",
+    "langchain-openai==1.3.3",
     "langfuse==4.9.1",
     "langgraph==1.2.6",
     "langgraph-checkpoint-postgres==3.1.0",

{sycommon_python_lib-0.2.7a1 → sycommon_python_lib-0.2.7a3}/src/sycommon/agent/deep_agent.py

@@ -88,9 +88,11 @@ def _patch_agent_streaming(agent):
     删除此函数及调用即可。
     """
     # 已验证兼容的版本范围(超出仅警告, 不阻断 —— 闭包强校验是真正的安全网)
-    # 1.3.10/1.4.8 经实测确认闭包结构兼容(amodel_node freevars 含 _execute_model_async,
-    # 内层 freevars 含 _get_bound_model/_handle_model_output), patch 正常生效。
-    _VERIFIED = {"langchain": "1.3.10", "langchain_core": "1.4.8"}
+    # 1.3.10/1.3.11 + langchain_core 1.4.8 经实测确认闭包结构兼容(amodel_node
+    # freevars 含 _execute_model_async, 内层 freevars 含 _get_bound_model/
+    # _handle_model_output), patch 正常生效。1.3.11 的 _execute_model_async 仍为
+    # ainvoke + 不传 config, 官方未修复, 补丁仍需保留。
+    _VERIFIED = {"langchain": "1.3.11", "langchain_core": "1.4.8"}
     try:
         import langchain as _lc
         import langchain_core as _lcc
@@ -249,11 +251,22 @@ def _patch_agent_streaming(agent):
             # 从 ContextVar 读取 LangGraph 注入的 config（含 StreamMessagesHandler）
             config = var_child_runnable_config.get()
 
-            # 用 astream 替代 ainvoke, 每个 token 触发 on_llm_new_token
+            # 用 astream 替代 ainvoke, 每个 token 规发 on_llm_new_token
             # 注意: ChatModel.astream() 产出的是 AIMessageChunk（BaseMessageChunk），
             # 不是 ChatGenerationChunk，因此累加结果直接就是消息本身，没有 .message 属性。
+            import time as _t
+            _t0 = _t.monotonic()
+            _msg_count = len(messages) if hasattr(messages, '__len__') else -1
+            SYLogger.info(
+                f"[LLM-CALL] astream 开始: model={getattr(model_, 'model', '?')}, "
+                f"messages={_msg_count} 条")
             chunks: list = []
+            _first_chunk_at = None
             async for chunk in model_.astream(messages, config=config):
+                if _first_chunk_at is None:
+                    _first_chunk_at = _t.monotonic()
+                    SYLogger.info(
+                        f"[LLM-CALL] 首个 chunk 到达, 耗时 {_first_chunk_at - _t0:.2f}s")
                 chunks.append(chunk)
 
             if not chunks:
@@ -262,6 +275,9 @@ def _patch_agent_streaming(agent):
                     "[StreamingPatch] astream returned empty, fallback to ainvoke")
                 output = await model_.ainvoke(messages, config=config)
             else:
+                SYLogger.info(
+                    f"[LLM-CALL] astream 结束, 共 {len(chunks)} 个 chunk, "
+                    f"总耗时 {_t.monotonic() - _t0:.2f}s")
                 generation = chunks[0]
                 for c in chunks[1:]:
                     generation += c

{sycommon_python_lib-0.2.7a1 → sycommon_python_lib-0.2.7a3}/src/sycommon/database/pg_checkpoint_service.py

@@ -73,7 +73,6 @@ class PgCheckpointService(metaclass=SingletonMeta):
             cls._config = PgConfig.from_dict(config)
 
             from psycopg_pool import AsyncConnectionPool
-            from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
 
             conn_string = cls._config.dsn
 
@@ -95,7 +94,14 @@ class PgCheckpointService(metaclass=SingletonMeta):
 
             await cls._pool.open()
 
-            cls._checkpointer = AsyncPostgresSaver(cls._pool)
+            # 🔑 使用自愈型 ResilientPostgresSaver 包装类（而非直接 AsyncPostgresSaver）
+            # 关键：reload() 会 close 旧池并新建池，但旧 agent 持有的 checkpointer
+            # 对象不会自动更换。ResilientPostgresSaver 的 .conn 动态读取 _pool，
+            # 池被关闭时自动重建重试，避免 PoolClosed 异常透传到上层。
+            # 复用已有包装实例（isinstance 守卫）：reload 时只换池，不换 checkpointer 对象。
+            from sycommon.database.resilient_pg_saver import ResilientPostgresSaver
+            if not isinstance(cls._checkpointer, ResilientPostgresSaver):
+                cls._checkpointer = ResilientPostgresSaver()
             await cls._checkpointer.setup()
 
             cls._initialized = True
@@ -151,8 +157,10 @@ class PgCheckpointService(metaclass=SingletonMeta):
             except Exception as e:
                 logging.error(f"关闭 PgCheckpointService 连接池失败: {e}")
             finally:
+                # 🔑 只清 _pool，保留 _checkpointer（ResilientPostgresSaver 包装对象）。
+                # reload() 重建后，包装对象的 .conn 动态读取新 _pool；
+                # 旧 agent 持有的包装引用无需更换即可继续工作。
                 cls._pool = None
-                cls._checkpointer = None
                 cls._initialized = False
 
     @classmethod
@@ -164,6 +172,8 @@ class PgCheckpointService(metaclass=SingletonMeta):
         """
         if not cls._initialized:
             return
+        old_pool = cls._pool
+        old_pool_id = id(old_pool)
         try:
             await cls.close()
         except Exception as e:
@@ -173,5 +183,9 @@ class PgCheckpointService(metaclass=SingletonMeta):
         cls._initialized = False
         try:
             await cls.setup()
+            new_pool_id = id(cls._pool) if cls._pool else None
+            logging.info(
+                f"PgCheckpointService reload 完成: old_pool_id={old_pool_id} "
+                f"-> new_pool_id={new_pool_id}, initialized={cls._initialized}")
         except Exception as e:
-            logging.error(f"PgCheckpointService reload 重建失败: {e}", exc_info=True)
+            logging.error(f"PgCheckpointService reload 重建失败: {e}", exc_info=True)

sycommon_python_lib-0.2.7a3/src/sycommon/database/resilient_pg_saver.py

@@ -0,0 +1,159 @@
+"""自愈型 PostgreSQL Checkpoint Saver
+
+解决 ``psycopg_pool.PoolClosed: the pool 'pool-1' is already closed`` 问题。
+
+根因：``PgCheckpointService.reload()`` 在 Nacos 配置热更新时会
+``close()`` 旧连接池（``_pool=None``）再 ``setup()`` 新建一个全新的
+``AsyncConnectionPool``。但此前创建的 agent（缓存在内存 sessions 中）已经
+捕获了旧的 ``AsyncPostgresSaver`` 对象，其 ``.conn`` 指向已关闭的旧池。
+LangGraph ``Pregel`` 永久持有该 checkpointer 引用，下次 ``aget_tuple`` 即
+抛 ``PoolClosed``。
+
+本类把"checkpointer 对象"与"连接池"解耦：对象只有一个（永久存活），
+``.conn`` 每次调用时动态读 ``PgCheckpointService._pool``；reload 只换池、
+不换对象。即便池处于被关闭的瞬态，热路径方法捕获 ``PoolClosed`` 后触发
+``_ensure_pool_alive`` 重建并精确重试一次，对上层透明。
+
+已对照 langgraph-checkpoint-postgres 3.1.0 源码验证：
+- ``AsyncPostgresSaver.__init__``（aio.py:57）执行 ``self.conn = conn``，
+  用 property + no-op setter 吸收，构造可存活。
+- ``self.conn`` 在 aio.py 中仅 ``_cursor``（aio.py:374）一处方法内读取，
+  所有热路径方法都只经由 ``self._cursor()`` 取池，无构造期缓存。
+"""
+import asyncio
+
+from psycopg_pool import PoolClosed
+from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
+
+from sycommon.logging.kafka_log import SYLogger
+
+# 自愈并发去重锁（模块级单例）。reload 跑在 Services 主 loop 上，多个并发
+# aget_tuple 同时撞上已关闭池时，只允许一个真正执行重建，其余进锁后双重
+# 检查发现池已恢复即直接返回。
+_heal_lock = asyncio.Lock()
+
+
+class ResilientPostgresSaver(AsyncPostgresSaver):
+    """跟随 ``PgCheckpointService._pool`` 的自愈型 checkpointer。
+
+    - 永久存活，跨 reload 不重建（见 ``PgCheckpointService.setup`` 的
+      ``isinstance`` 守卫）。
+    - ``conn`` property 动态返回当前活跃池；池被关闭时热路径方法自动重建。
+    """
+
+    def __init__(self) -> None:
+        # 父类 __init__ 会执行 self.conn = conn；property + no-op setter
+        # 吸收该赋值。传 conn=None/pipe=None 避开父类 "pool + pipe 不能同时
+        # 非空" 的 guard（aio.py:52）。self.lock/self.loop 由父类设置，跨
+        # reload 安全（主 loop 不变）。
+        super().__init__(conn=None, pipe=None)
+
+    # ------------------------------------------------------------------ conn
+    @property
+    def conn(self):  # type: ignore[override]
+        """动态返回当前活跃连接池。
+
+        池不存在或已关闭时 raise ``PoolClosed``，保持与底层一致的失败语义，
+        交由热路径方法的 try/except 捕获后自愈。
+        """
+        from sycommon.database.pg_checkpoint_service import PgCheckpointService
+        pool = PgCheckpointService._pool
+        if pool is None or getattr(pool, "closed", True):
+            raise PoolClosed(
+                f"the pool {getattr(pool, 'name', 'pool-1')!r} is already closed "
+                f"(or not initialized)"
+            )
+        return pool
+
+    @conn.setter
+    def conn(self, value):  # noqa: D401
+        """no-op：吸收父类 ``__init__`` 的 ``self.conn = conn`` 赋值。
+
+        实际连接池永远通过 getter 动态从 ``PgCheckpointService`` 读取，
+        不缓存任何传入值。
+        """
+        return
+
+    # ------------------------------------------------------------- 自愈核心
+    async def _ensure_pool_alive(self) -> None:
+        """若连接池已关闭/未初始化，触发一次重建（并发去重）。
+
+        双重检查：进锁后再查一次池状态，避免多个并发调用重复 reload。
+        """
+        from sycommon.database.pg_checkpoint_service import PgCheckpointService
+
+        # 锁外快查：池可用就直接返回，绝大多数请求走这条快路径
+        pool = PgCheckpointService._pool
+        if pool is not None and not getattr(pool, "closed", True):
+            return
+
+        async with _heal_lock:
+            # 锁内再次检查：可能已有并发协程完成了重建
+            pool = PgCheckpointService._pool
+            if pool is not None and not getattr(pool, "closed", True):
+                return
+            old_pool_id = id(pool)
+            SYLogger.info(
+                f"[ResilientPgSaver] pool closed, triggering self-heal "
+                f"(old_pool_id={old_pool_id})")
+            try:
+                await PgCheckpointService.reload()
+            except Exception as e:
+                SYLogger.error(
+                    f"[ResilientPgSaver] self-heal reload 失败: {e}",
+                    exc_info=True)
+                raise
+            new_pool = PgCheckpointService._pool
+            SYLogger.info(
+                f"[ResilientPgSaver] self-heal 完成 "
+                f"(old_pool_id={old_pool_id} -> new_pool_id={id(new_pool)})")
+
+    # ----------------------------------------------------- 热路径方法重试
+    # 统一模式：捕获 PoolClosed -> 自愈 -> 精确一次重试。
+    # PoolClosed 实际只在打开 cursor（首次从池里取连接）时出现，重试是安全的。
+    async def aget_tuple(self, config):
+        try:
+            return await super().aget_tuple(config)
+        except PoolClosed:
+            await self._ensure_pool_alive()
+            return await super().aget_tuple(config)
+
+    async def aput(self, config, checkpoint, metadata, new_versions):
+        try:
+            return await super().aput(config, checkpoint, metadata, new_versions)
+        except PoolClosed:
+            await self._ensure_pool_alive()
+            return await super().aput(config, checkpoint, metadata, new_versions)
+
+    async def aput_writes(self, config, writes, task_id, task_path=""):
+        try:
+            return await super().aput_writes(config, writes, task_id, task_path)
+        except PoolClosed:
+            await self._ensure_pool_alive()
+            return await super().aput_writes(config, writes, task_id, task_path)
+
+    async def adelete_thread(self, thread_id):
+        try:
+            return await super().adelete_thread(thread_id)
+        except PoolClosed:
+            await self._ensure_pool_alive()
+            return await super().adelete_thread(thread_id)
+
+    async def alist(self, config, *, filter=None, before=None, limit=None):
+        """异步生成器：首条 PoolClosed 自愈后重新遍历整条流。
+
+        PoolClosed 只在 cursor 打开（首次取连接）时出现，因此重建后重头
+        遍历是安全且语义正确的契约（不会漏放或重放 checkpoint tuple）。
+        """
+        try:
+            async for item in super().alist(
+                config, filter=filter, before=before, limit=limit
+            ):
+                yield item
+            return
+        except PoolClosed:
+            await self._ensure_pool_alive()
+        async for item in super().alist(
+            config, filter=filter, before=before, limit=limit
+        ):
+            yield item

{sycommon_python_lib-0.2.7a1 → sycommon_python_lib-0.2.7a3}/src/sycommon/heartbeat_process/heartbeat_config.py

@@ -109,6 +109,9 @@ class LogConfig:
     namespace_id: str                           # 命名空间 ID（用于 env 字段）
     kafka_servers: Optional[str] = None         # Kafka 服务器地址
     kafka_topic: str = "shengye-json-log"       # Kafka topic
+    # 全局总开关：false 时不发 kafka。默认 True（未配置/老服务零破坏）。
+    # 独立进程（心跳/MQ 进程池）跟随全局 log.enabled，不支持单条强制。
+    log_enabled: bool = True
 
     @classmethod
     def from_nacos_config(cls, nacos_config: dict, service_name: str, shared_configs: dict = None) -> 'LogConfig':
@@ -123,15 +126,21 @@ class LogConfig:
             LogConfig 实例
         """
         kafka_servers = None
+        log_enabled = True
 
-        # 尝试从 shared_configs 获取 Kafka 配置
+        # 尝试从 shared_configs 获取 Kafka 配置 + 总开关
         if shared_configs and isinstance(shared_configs, dict):
             common_config = shared_configs.get("common.yml", {})
             if isinstance(common_config, dict):
-                kafka_servers = common_config.get('log', {}).get('kafka', {}).get('servers')
+                log_cfg = common_config.get('log', {})
+                if isinstance(log_cfg, dict):
+                    kafka_servers = log_cfg.get('kafka', {}).get('servers')
+                    if 'enabled' in log_cfg:
+                        log_enabled = bool(log_cfg['enabled'])
 
         return cls(
             service_name=service_name,
             namespace_id=nacos_config.get('namespaceId', ''),
-            kafka_servers=kafka_servers
+            kafka_servers=kafka_servers,
+            log_enabled=log_enabled
         )

{sycommon_python_lib-0.2.7a1 → sycommon_python_lib-0.2.7a3}/src/sycommon/logging/kafka_log.py

@@ -26,6 +26,34 @@ LOGURU_FORMAT = (
 )
 
 
+def _global_log_enabled() -> bool:
+    """读取 log.enabled 总开关。未配置 -> True（零破坏）。
+
+    读取顺序同 log_masker：项目自身 yaml 的 log.enabled 覆盖 common.yml 的
+    log.enabled；都未写 -> True。Config 未就绪（本地 dev / 启动早期）-> True，
+    避免启动阶段日志丢失。
+
+    false = 关闭所有 kafka 日志 + 本地打印（单条 enabled=True 除外，见 SYLogger）。
+    """
+    try:
+        cfg_root = Config().config or {}
+    except Exception:
+        return True
+    if not isinstance(cfg_root, dict):
+        return True
+    common = (cfg_root.get("common.yml") or {}).get("log", {}) \
+        if isinstance(cfg_root.get("common.yml"), dict) else {}
+    app_name = cfg_root.get("Name", "")
+    project = (cfg_root.get(app_name) or {}).get("log", {}) \
+        if app_name and isinstance(cfg_root.get(app_name), dict) else {}
+    # 项目覆盖 common；都未写 enabled -> True
+    if "enabled" in project:
+        return bool(project["enabled"])
+    if "enabled" in common:
+        return bool(common["enabled"])
+    return True
+
+
 class KafkaSink:
     """
     自定义 Loguru Sink，负责格式化日志并发送到 Kafka
@@ -33,15 +61,36 @@ class KafkaSink:
 
     def __init__(self, service_id: str):
         self.service_id = service_id
-        # 获取配置
+        # 获取配置（缓存 bootstrap_servers，供全局关闭时强制日志/ERROR 惰性建 producer 复用）
         from sycommon.synacos.nacos_service import NacosService
         common = NacosService(
             Config().config).share_configs.get("common.yml", {})
-        bootstrap_servers = common.get("log", {}).get(
+        self._bootstrap_servers = common.get("log", {}).get(
             "kafka", {}).get("servers", None)
 
-        self._producer_obj = KafkaProducer(
-            bootstrap_servers=bootstrap_servers,
+        # 全局总开关：false 时不建 producer，write() 在收到 ERROR / 强制日志时
+        # （单条 enabled=True）才惰性补建，从而彻底静默普通日志。
+        self._enabled = _global_log_enabled()
+        self._closed = False
+        self._producer_obj = self._build_producer() if self._enabled else None
+        self._producer = self._producer_obj
+
+        # 缓存主机信息，避免每次日志写入都做 DNS 解析
+        try:
+            self._ip = socket.gethostbyname(socket.gethostname())
+        except Exception:
+            self._ip = '127.0.0.1'
+        self._host_name = socket.gethostname()
+
+    def _build_producer(self):
+        """构建 KafkaProducer，供 __init__ 与全局关闭时的强制日志/ERROR 惰性复用。
+
+        注意：kafka-python 的 KafkaProducer 在构造时会尝试拉取元数据，
+        broker 不可达时可能抛异常——此处不吞异常，由调用方决定
+        （__init__ 保持原启动期失败即抛的行为；write() 的惰性路径 try 包裹）。
+        """
+        return KafkaProducer(
+            bootstrap_servers=self._bootstrap_servers,
             value_serializer=lambda v: json.dumps(
                 v, ensure_ascii=False).encode('utf-8'),
             # 保持原有的优化配置
@@ -52,14 +101,6 @@ class KafkaSink:
             batch_size=16384,
             linger_ms=5,
         )
-        self._producer = self._producer_obj
-
-        # 缓存主机信息，避免每次日志写入都做 DNS 解析
-        try:
-            self._ip = socket.gethostbyname(socket.gethostname())
-        except Exception:
-            self._ip = '127.0.0.1'
-        self._host_name = socket.gethostname()
 
     def write(self, message):
         """
@@ -67,9 +108,26 @@ class KafkaSink:
         message 参数实际上是 loguru.Message 对象，可以通过 message.record 获取所有字段。
         """
         try:
+            # sink 已显式关闭（shutdown/reload 重建）：不再发任何日志
+            if self._closed:
+                return
+
             # producer 已关闭则跳过
             if self._producer is None:
-                return
+                # 全局关闭（_enabled=False 时未建 producer）：仅放行 ERROR 与
+                # 单条强制日志（enabled=True），并为它们惰性补建一次 producer。
+                record = message.record
+                is_error = record["level"].name == "ERROR"
+                is_forced = record["extra"].get("_log_forced")
+                if not (is_error or is_forced):
+                    return
+                try:
+                    self._producer_obj = self._build_producer()
+                    self._producer = self._producer_obj
+                except Exception:
+                    return
+                if self._producer is None:
+                    return
 
             # 1. 获取原始日志记录
             record = message.record
@@ -169,6 +227,8 @@ class KafkaSink:
 
     def close(self):
         """关闭 KafkaProducer，释放连接池资源"""
+        # 标记已关闭，阻止 write() 继续发送（含惰性补建 producer 的路径）
+        self._closed = True
         if self._producer_obj is None:
             return
         # 先移除引用，阻止 write() 继续发送新消息
@@ -222,14 +282,18 @@ class KafkaLogger(metaclass=SingletonMeta):
             diagnose=True
         )
 
-        logger.add(
-            sink=sys.stdout,
-            level="ERROR",
-            format=LOGURU_FORMAT,
-            colorize=True,
-            backtrace=True,
-            diagnose=True
-        )
+        # ERROR 本地打印：仅全局开关开启时注册。
+        # 全局关闭（log.enabled=false）时不本地打印——ERROR 日志仍会进 kafka
+        # （KafkaSink.write 对 ERROR 放行并惰性建 producer），但 stdout 静默。
+        if KafkaLogger._sink_instance._enabled:
+            logger.add(
+                sink=sys.stdout,
+                level="ERROR",
+                format=LOGURU_FORMAT,
+                colorize=True,
+                backtrace=True,
+                diagnose=True
+            )
 
         # 桥接 stdlib logging → Loguru，捕获 asyncio 等第三方库的日志
         intercept_handler = _InterceptHandler()
@@ -374,11 +438,28 @@ class SYLogger:
         return f"thread:{threading.current_thread().name}"
 
     @staticmethod
-    def _log(msg: any, level: str = "INFO"):
+    def _log(msg: any, level: str = "INFO", enabled: bool = None):
         """
         统一日志记录入口
         修复：手动提取堆栈信息并写入 message，确保 Kafka 能收到
+
+        单条开关（enabled）：
+            - None（默认）：跟随全局 log.enabled。全局关 -> 静默（ERROR 除外，ERROR 始终放行）
+            - True：强制发出（即便全局 log.enabled=false，这一条也进 kafka）
+            - False：强制静默（即便全局开，这一条也丢）
+
+        注意：ERROR 级别无论全局开关如何都会进 kafka（KafkaSink.write 对 ERROR 放行），
+        此处的 enabled=None + 全局关 对 ERROR 不静默——仅在 enabled=False 时才压制。
         """
+        # 单条开关裁决
+        if enabled is False:
+            return  # 强制静默
+
+        global_on = _global_log_enabled()
+        # 跟随全局且全局关：非 ERROR 静默（ERROR 始终放行，交由 KafkaSink 处理）
+        if enabled is None and not global_on and level != "ERROR":
+            return
+
         # 序列化消息：dict/list 先脱敏（按字段名/子串/长度/总量裁剪），再转 JSON
         if isinstance(msg, (dict, list)):
             msg = _log_masker.sanitize(msg)
@@ -410,35 +491,42 @@ class SYLogger:
         # 将字典转为 JSON 字符串传给 Loguru
         log_json = json.dumps(log_dict, ensure_ascii=False)
 
+        # 全局关时，单条 enabled=True 需打 _log_forced 标记，KafkaSink 据此放行
+        # （ERROR 在 KafkaSink 已放行，无需标记；这里只为非 ERROR 的强制日志打标）。
+        if enabled is True and not global_on and level != "ERROR":
+            lg = logger.bind(_log_forced=True)
+        else:
+            lg = logger
+
         if level == "ERROR":
             # 依然使用 opt(exception=True) 让控制台打印彩色堆栈
             # 注意：Loguru 内部可能会忽略我们已经塞进去的 detail 字符串，
             # 但这没关系，因为 KafkaSink 解析 message 字符串时会重新读取 detail
-            logger.opt(exception=True).error(log_json)
+            lg.opt(exception=True).error(log_json)
         elif level == "WARNING":
-            logger.warning(log_json)
+            lg.warning(log_json)
         else:
-            logger.info(log_json)
+            lg.info(log_json)
 
         if check_env_flag(['DEV_LOG']):
             print(log_dict)
 
     @staticmethod
-    def info(msg: any, *args, **kwargs):
-        SYLogger._log(msg, "INFO")
+    def info(msg: any, *args, enabled: bool = None, **kwargs):
+        SYLogger._log(msg, "INFO", enabled)
 
     @staticmethod
-    def warning(msg: any, *args, **kwargs):
-        SYLogger._log(msg, "WARNING")
+    def warning(msg: any, *args, enabled: bool = None, **kwargs):
+        SYLogger._log(msg, "WARNING", enabled)
 
     @staticmethod
-    def debug(msg: any, *args, **kwargs):
-        SYLogger._log(msg, "DEBUG")
+    def debug(msg: any, *args, enabled: bool = None, **kwargs):
+        SYLogger._log(msg, "DEBUG", enabled)
 
     @staticmethod
-    def error(msg: any, *args, **kwargs):
-        SYLogger._log(msg, "ERROR")
+    def error(msg: any, *args, enabled: bool = None, **kwargs):
+        SYLogger._log(msg, "ERROR", enabled)
 
     @staticmethod
-    def exception(msg: any, *args, **kwargs):
-        SYLogger._log(msg, "ERROR")
+    def exception(msg: any, *args, enabled: bool = None, **kwargs):
+        SYLogger._log(msg, "ERROR", enabled)

{sycommon_python_lib-0.2.7a1 → sycommon_python_lib-0.2.7a3}/src/sycommon/logging/process_logger.py

@@ -58,6 +58,11 @@ class ProcessLogger:
             if self._initialized:
                 return self._producer is not None
 
+            # 全局总开关关闭：不建 producer（独立进程跟随全局 log.enabled）
+            if not getattr(self.log_config, 'log_enabled', True):
+                self._initialized = True
+                return False
+
             try:
                 if self.log_config.kafka_servers:
                     from kafka import KafkaProducer
@@ -102,6 +107,10 @@ class ProcessLogger:
             msg: 日志消息
             level: 日志级别
         """
+        # 全局总开关：关闭则不发 kafka（独立进程跟随全局，不支持单条强制）
+        if not getattr(self.log_config, 'log_enabled', True):
+            return
+
         # 序列化消息
         if isinstance(msg, dict) or isinstance(msg, list):
             msg_str = json.dumps(msg, ensure_ascii=False)

{sycommon_python_lib-0.2.7a1 → sycommon_python_lib-0.2.7a3}/src/sycommon_python_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.7a1
+Version: 0.2.7a3
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -14,9 +14,9 @@ Requires-Dist: elasticsearch==9.4.1
 Requires-Dist: fastapi==0.138.0
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: kafka-python==3.0.2
-Requires-Dist: langchain==1.3.10
+Requires-Dist: langchain==1.3.11
 Requires-Dist: langchain-core==1.4.8
-Requires-Dist: langchain-openai==1.3.2
+Requires-Dist: langchain-openai==1.3.3
 Requires-Dist: langfuse==4.9.1
 Requires-Dist: langgraph==1.2.6
 Requires-Dist: langgraph-checkpoint-postgres==3.1.0

{sycommon_python_lib-0.2.7a1 → sycommon_python_lib-0.2.7a3}/src/sycommon_python_lib.egg-info/SOURCES.txt

@@ -185,6 +185,7 @@ src/sycommon/database/database_service.py
 src/sycommon/database/elasticsearch_service.py
 src/sycommon/database/pg_checkpoint_service.py
 src/sycommon/database/redis_service.py
+src/sycommon/database/resilient_pg_saver.py
 src/sycommon/database/token_usage_db_service.py
 src/sycommon/health/__init__.py
 src/sycommon/health/health_check.py
@@ -313,5 +314,6 @@ tests/test_asyncio_logging.py
 tests/test_config_change_notifier.py
 tests/test_hotreload_snapshot.py
 tests/test_log_masker.py
+tests/test_resilient_pg_saver.py
 tests/test_simple_chat_agent.py
 tests/test_sycli.py

{sycommon_python_lib-0.2.7a1 → sycommon_python_lib-0.2.7a3}/src/sycommon_python_lib.egg-info/requires.txt

@@ -8,9 +8,9 @@ elasticsearch==9.4.1
 fastapi==0.138.0
 jinja2==3.1.6
 kafka-python==3.0.2
-langchain==1.3.10
+langchain==1.3.11
 langchain-core==1.4.8
-langchain-openai==1.3.2
+langchain-openai==1.3.3
 langfuse==4.9.1
 langgraph==1.2.6
 langgraph-checkpoint-postgres==3.1.0