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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.7a2
+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.7a2 → sycommon_python_lib-0.2.7a3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.7a2"
+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.7a2 → 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.7a2 → 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.7a2 → 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.7a2 → 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.7a2 → 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.7a2
+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.7a2 → 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