sycommon-python-lib 0.2.10a3__tar.gz → 0.2.10a5__tar.gz

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.10a3
+Version: 0.2.10a5
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -13,36 +13,36 @@ Requires-Dist: deepagents==0.7.6
 Requires-Dist: elasticsearch==9.5.0
 Requires-Dist: fastapi==0.141.1
 Requires-Dist: jinja2==3.1.6
-Requires-Dist: kafka-python==3.0.10
-Requires-Dist: langchain==1.3.15
-Requires-Dist: langchain-core==1.5.5
-Requires-Dist: langchain-openai==1.5.1
-Requires-Dist: langfuse==4.14.4
+Requires-Dist: kafka-python==3.0.11
+Requires-Dist: langchain==1.3.18
+Requires-Dist: langchain-core==1.6.1
+Requires-Dist: langchain-openai==1.6.0
+Requires-Dist: langfuse==4.15.1
 Requires-Dist: langgraph==1.2.11
 Requires-Dist: langgraph-checkpoint-postgres==3.1.2
-Requires-Dist: langgraph-checkpoint-redis==0.5.1
+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: psutil==7.2.2
 Requires-Dist: pyxxl==0.4.8
-Requires-Dist: pydantic==2.13.4
-Requires-Dist: python-dotenv==1.2.2
+Requires-Dist: pydantic==2.13.5
+Requires-Dist: python-dotenv==1.2.3
 Requires-Dist: python-multipart==0.0.32
 Requires-Dist: pyyaml==6.0.3
 Requires-Dist: redis==7.4.0
-Requires-Dist: sentry-sdk[fastapi]==2.68.0
+Requires-Dist: sentry-sdk[fastapi]==2.68.1
 Requires-Dist: sqlalchemy[asyncio]==2.0.52
 Requires-Dist: starlette[full]==1.6.0
-Requires-Dist: tiktoken==0.13.0
-Requires-Dist: uvicorn==0.52.3
+Requires-Dist: tiktoken==0.14.0
+Requires-Dist: uvicorn==0.52.4
 Requires-Dist: wecom-aibot-python-sdk==1.0.2
 Requires-Dist: twine==7.0.0
 Requires-Dist: minio==7.2.20
 Requires-Dist: langchain-mcp-adapters==0.3.2
 Requires-Dist: fastapi-mcp==0.4.0
-Requires-Dist: psycopg[binary,pool]==3.3.4
+Requires-Dist: psycopg[binary,pool]==3.3.5
 Requires-Dist: agent-client-protocol==0.11.0
 Requires-Dist: langchain-acp==1.7.0
 Requires-Dist: pypinyin==0.55.0

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.10a3"
+version = "0.2.10a5"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -14,36 +14,36 @@ dependencies = [
     "elasticsearch==9.5.0",
     "fastapi==0.141.1",
     "jinja2==3.1.6",
-    "kafka-python==3.0.10",
-    "langchain==1.3.15",
-    "langchain-core==1.5.5",
-    "langchain-openai==1.5.1",
-    "langfuse==4.14.4",
+    "kafka-python==3.0.11",
+    "langchain==1.3.18", 
+    "langchain-core==1.6.1",
+    "langchain-openai==1.6.0",
+    "langfuse==4.15.1",
     "langgraph==1.2.11",
     "langgraph-checkpoint-postgres==3.1.2",
-    "langgraph-checkpoint-redis==0.5.1",
+    "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",
     "psutil==7.2.2",
     "pyxxl==0.4.8",
-    "pydantic==2.13.4",
-    "python-dotenv==1.2.2",
+    "pydantic==2.13.5",
+    "python-dotenv==1.2.3",
     "python-multipart==0.0.32",
     "pyyaml==6.0.3",
     "redis==7.4.0",
-    "sentry-sdk[fastapi]==2.68.0",
+    "sentry-sdk[fastapi]==2.68.1",
     "sqlalchemy[asyncio]==2.0.52",
     "starlette[full]==1.6.0",
-    "tiktoken==0.13.0",
-    "uvicorn==0.52.3",
+    "tiktoken==0.14.0",
+    "uvicorn==0.52.4",
     "wecom-aibot-python-sdk==1.0.2",
     "twine==7.0.0",
     "minio==7.2.20",
     "langchain-mcp-adapters==0.3.2",
     "fastapi-mcp==0.4.0",
-    "psycopg[binary,pool]==3.3.4",
+    "psycopg[binary,pool]==3.3.5",
     "agent-client-protocol==0.11.0",
     "langchain-acp==1.7.0",
     "pypinyin==0.55.0",

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/src/sycommon/agent/sandbox/minio_sync.py

@@ -886,6 +886,25 @@ class MinioSyncService(metaclass=SingletonMeta):
 
     # ============== 反向同步（MinIO → 沙箱） ==============
 
+    def _download_object_to_file(self, key: str, dest: str) -> int:
+        """流式下载 MinIO 对象到本地文件（同步，跑在 to_thread），返回字节数。
+
+        替代旧 resp.read() 整文件进内存：大附件场景一批 5 路并发 × 全量驻留
+        = 数百 MB~GB 级 RSS 峰值（打爆内存的根因）。流式写盘后内存峰值 ≈ 单块，
+        与文件大小无关；与 _sync_one 的 adownload_to_file 落盘模式对称。
+        """
+        resp = self._client.get_object(self._bucket, key)
+        try:
+            total = 0
+            with open(dest, "wb") as f:
+                for chunk in resp.stream(5 * 1024 * 1024):
+                    f.write(chunk)
+                    total += len(chunk)
+            return total
+        finally:
+            resp.close()
+            resp.release_conn()
+
     async def restore_from_minio(self, sandbox_backend, user_id: str) -> int:
         """将 MinIO 中的文件恢复到沙箱
 
@@ -953,9 +972,14 @@ class MinioSyncService(metaclass=SingletonMeta):
         #     打满线程池、挤占主请求路径的沙箱操作。
         # 下载协程先抢本用户 5 槽、再抢全局 100 槽，故实际并发 = min(本用户待下载, 全局剩余)。
         #
-        # 🔑 OOM 兜底：旧实现 gather 所有文件内容进 downloaded 列表后才上传，用户文件多/大
-        #   一次几 GB 进内存。改为【分批流水线】：下 _RESTORE_PER_USER 个→立即上传→字节出作用域
-        #   →下一批。同时按 list_objects 的 size 累加 total_bytes_seen，超 _MAX_RESTORE_BYTES 跳过剩余。
+        # 🔑 OOM 治理（两处放大器都已拔掉）：
+        #   - 上传侧旧实现 gather 所有文件内容进 downloaded 列表后才 base64 整包传沙箱，
+        #     用户文件多/大时一次几 GB 进内存 → 改【分批流水线】+ 每批立即上传；
+        #   - 下载侧旧实现 resp.read() 把整文件读进内存，单个大附件即百 MB 级驻留
+        #     → 改【流式落盘】：MinIO 5MB 块写临时文件 → aupload_stream_from_disk
+        #     逐块读盘推沙箱 → 删临时文件，内存峰值 ≈ 单块，与文件大小无关。
+        #   另按 list_objects 的 size 累加 total_bytes_seen，超 _MAX_RESTORE_BYTES 跳过剩余
+        #   （仅 warning，会话末尾全量扫描兜底）。
         restored = 0
         global_sem = _get_restore_download_sem()
         per_user_sem = asyncio.Semaphore(_RESTORE_PER_USER)
@@ -964,26 +988,43 @@ class MinioSyncService(metaclass=SingletonMeta):
         obj_size_map = {o.object_name[len(prefix):]: (o.size or 0) for o in objects}
 
         async def _download_one(rel_path: str):
-            """下载单个 MinIO 对象到内存，返回 (沙箱绝对路径, 内容) 或 None。"""
+            """下载单个 MinIO 对象【流式落盘】再流式上传沙箱，成功 True 失败 None。
+
+            全程不把整文件 bytes 攒进内存：MinIO 5MB 块写临时文件 →
+            aupload_stream_from_disk 逐块读盘推沙箱 → 删临时文件。
+            """
+            tmp_path = None
             async with per_user_sem, global_sem:
                 try:
-                    def _download_object(bucket, key):
-                        resp = self._client.get_object(bucket, key)
-                        try:
-                            return resp.read()
-                        finally:
-                            resp.close()
-                            resp.release_conn()
-
-                    content = await asyncio.to_thread(
-                        _download_object, self._bucket, f"{prefix}{rel_path}"
+                    import tempfile as _tf
+                    with _tf.NamedTemporaryFile(delete=False) as tmp:
+                        tmp_path = tmp.name
+                    fsize = await asyncio.to_thread(
+                        self._download_object_to_file,
+                        f"{prefix}{rel_path}", tmp_path
+                    )
+                    if fsize == 0:
+                        SYLogger.warning(f"[MinIO] 下载文件为空/失败: {rel_path}")
+                        return None
+                    r = await sandbox_backend.aupload_stream_from_disk(
+                        f"/{rel_path}", tmp_path
                     )
-                    return (f"/{rel_path}", content)
+                    if getattr(r, "error", None):
+                        SYLogger.warning(
+                            f"[MinIO] 上传到沙箱失败: {rel_path}, error={r.error}")
+                        return None
+                    return rel_path
                 except Exception as e:
                     SYLogger.warning(f"[MinIO] 下载文件失败: {rel_path}, error: {e}")
                     return None
+                finally:
+                    if tmp_path:
+                        try:
+                            os.unlink(tmp_path)
+                        except OSError:
+                            pass
 
-        # 分批流水线：下 N 个 → 传 N 个 → 字节随 downloaded/download_results 出作用域释放
+        # 分批流水线：下 N 个 → 传 N 个 → 临时文件随 _download_one finally 删除
         total_bytes_seen = 0
         capped = False
         batch_size = _RESTORE_PER_USER
@@ -1010,18 +1051,7 @@ class MinioSyncService(metaclass=SingletonMeta):
                 *[_download_one(rp) for rp in batch_paths]
             )
             downloaded = [r for r in download_results if r is not None]
-            if not downloaded:
-                continue
-            try:
-                results = await sandbox_backend.aupload_files(downloaded)
-                for r in results:
-                    if not r.error:
-                        restored += 1
-                    else:
-                        SYLogger.warning(
-                            f"[MinIO] 上传到沙箱失败: {r.path}, error={r.error}")
-            except Exception as e:
-                SYLogger.warning(f"[MinIO] 批量上传到沙箱失败: {e}")
+            restored += len(downloaded)
             # downloaded / download_results 到此出作用域，下一批前可被 GC
 
         if capped:

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/src/sycommon/database/async_database_service.py

@@ -212,7 +212,11 @@ class AsyncDatabaseConnector:
         def tune_keepalive(dbapi_connection, connection_record):
             import socket as _socket
             try:
-                writer = getattr(dbapi_connection, "_writer", None)
+                # SQLAlchemy 2.x 异步方言把 aiomysql 连接包在
+                # AsyncAdapt_aiomysql_connection._connection 里；老版本/裸 aiomysql
+                # 则直接挂 _writer。两级都探测。
+                inner = getattr(dbapi_connection, "_connection", dbapi_connection)
+                writer = getattr(inner, "_writer", None)
                 transport = getattr(writer, "transport", None)
                 raw_sock = transport.get_extra_info("socket") if transport else None
                 if raw_sock is None:

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/src/sycommon/database/database_service.py

@@ -1,3 +1,5 @@
+import sys
+
 from sqlalchemy import create_engine, text, event
 
 from sycommon.config.Config import SingletonMeta
@@ -106,17 +108,57 @@ class DatabaseConnector(metaclass=SingletonMeta):
         SYLogger.info(f"Database URL: {safe_url}")
 
         # 优化连接池配置
+        # 🔑 同步引擎与异步引擎（AsyncDatabaseConnector）同源风险：池中空闲连接被中间
+        # 网络设备静默掐死（不回 RST）时，pre_ping 的 SELECT 1 发进黑洞，会挂到内核
+        # TCP 重传放弃。分驱动两层防护（实测验证，见 test_db_keepalive.py）：
+        # - C 扩展（CMySQLConnection，装了 _mysql_driver 时默认）：不暴露 Python 层
+        #   socket，keepalive 钩子拿不到 raw socket；用 read_timeout=60 兜底——黑洞
+        #   读挂死 60s 后抛错，pre_ping 捕获弃连重建（真实环境已验证 SELECT SLEEP
+        #   按 read_timeout 抛 OperationalError）。
+        # - pure 实现（MySQLConnection）：钩子对 _socket.sock 补 keepalive 参数，
+        #   死连接 ~60s 内被内核暴露为错误（与异步侧 73f2156 同一套参数）。
         self.engine = create_engine(
             self.db_url,
-            connect_args=params,
+            connect_args={
+                **params,
+                "connect_timeout": 10,  # TCP 建连超时（秒）
+                "read_timeout": 60,  # 查询级读超时（秒）：C 扩展拿不到 socket 时的黑洞兜底
+                "write_timeout": 60,  # 写超时（秒）：同上
+            },
             pool_size=10,  # 连接池大小
             max_overflow=20,  # 最大溢出连接数
             pool_timeout=30,  # 连接超时时间（秒）
-            pool_recycle=3600,  # 连接回收时间（秒）
+            pool_recycle=300,  # 连接回收时间（秒）；赶在防火墙空闲回收窗口（常见 5-15min）前换血
             pool_pre_ping=True,  # 每次获取连接前检查连接是否有效
             echo=False,  # 打印 SQL 语句
         )
 
+        # 每个新连接补齐 TCP keepalive 参数（连接建立后才能拿到 raw socket）
+        @event.listens_for(self.engine, "connect")
+        def tune_keepalive(dbapi_connection, connection_record):
+            import socket as _socket
+            try:
+                # mysql-connector-python: raw socket 在 MySQLSocket 包装对象的 .sock 上
+                sock_wrapper = getattr(dbapi_connection, "_socket", None)
+                raw_sock = getattr(sock_wrapper, "sock", None)
+                if raw_sock is None:
+                    return
+                raw_sock.setsockopt(_socket.SOL_SOCKET, _socket.SO_KEEPALIVE, 1)
+                if sys.platform == "win32":
+                    # Windows: SIO_KEEPALIVE_VALS = (on/off, idle ms, interval ms)
+                    raw_sock.ioctl(_socket.SIO_KEEPALIVE_VALS, (1, 30000, 10000))
+                else:
+                    # Linux: 空闲 30s 发首个探测，每 10s 一次，3 次无回应判死（约 60s 暴露）
+                    if hasattr(_socket, "TCP_KEEPIDLE"):
+                        raw_sock.setsockopt(_socket.IPPROTO_TCP, _socket.TCP_KEEPIDLE, 30)
+                    if hasattr(_socket, "TCP_KEEPINTVL"):
+                        raw_sock.setsockopt(_socket.IPPROTO_TCP, _socket.TCP_KEEPINTVL, 10)
+                    if hasattr(_socket, "TCP_KEEPCNT"):
+                        raw_sock.setsockopt(_socket.IPPROTO_TCP, _socket.TCP_KEEPCNT, 3)
+            except Exception as e:
+                # keepalive 调优失败不阻断连接创建（回退内核默认）
+                SYLogger.warning(f"TCP keepalive 调优失败（回退默认）: {e}")
+
         # 注册 SQL 日志拦截器
         SQLTraceLogger.setup_sql_logging(self.engine)
 

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/src/sycommon/database/redis_service.py

@@ -3,6 +3,8 @@ Redis 异步服务
 使用 redis-py 官方异步客户端
 """
 import logging
+import socket
+import sys
 from typing import Optional, Any, Union
 
 from sycommon.config.Config import SingletonMeta
@@ -32,6 +34,18 @@ class RedisService(metaclass=SingletonMeta):
         """
         cls.init(config)
 
+    # TCP keepalive 探测参数：空闲 30s 首探、每 10s 一次、3 次无回应判死。
+    # 与 MySQL 引擎同套参数（见 async_database_service.py tune_keepalive）。
+    # redis-py 只按平台常量透传 setsockopt；macOS 用 TCP_KEEPALIVE 表 idle。
+    # Windows 无 per-socket keepalive 常量（需 SIO_KEEPALIVE_VALS ioctl），
+    # 且其 TCP_KEEPALIVE 语义不同，透传会抛 WSAENOPROTOOPT —— 直接留空回退默认。
+    _KEEPALIVE_OPTIONS = {} if sys.platform == "win32" else {
+        getattr(socket, name, None): value
+        for name, value in (("TCP_KEEPIDLE", 30), ("TCP_KEEPALIVE", 30),
+                            ("TCP_KEEPINTVL", 10), ("TCP_KEEPCNT", 3))
+        if getattr(socket, name, None) is not None
+    }
+
     @classmethod
     def init(cls, config: Optional[dict] = None):
         """
@@ -104,6 +118,8 @@ class RedisService(metaclass=SingletonMeta):
             db=cls._config.database,
             max_connections=max_connections,
             socket_timeout=cls._config.timeout,
+            socket_keepalive=True,  # 开 TCP keepalive；探测参数见下方 _KEEPALIVE_OPTIONS
+            socket_keepalive_options=RedisService._KEEPALIVE_OPTIONS,
             decode_responses=True  # 自动解码为字符串
         )
 
@@ -151,6 +167,8 @@ class RedisService(metaclass=SingletonMeta):
         cls._client = sentinel.master_for(
             sentinel_config.master,
             socket_timeout=cls._config.timeout,
+            socket_keepalive=True,  # 与单机模式一致，防空闲连接被静默掐死
+            socket_keepalive_options=RedisService._KEEPALIVE_OPTIONS,
             password=cls._config.password,
             db=cls._config.database,
             decode_responses=True

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/src/sycommon/database/token_usage_db_service.py

@@ -3,10 +3,11 @@ Token 使用量记录专用数据库服务
 独立于业务系统的数据库连接，使用 llm 配置中的数据库信息
 """
 import logging
+import sys
 from contextlib import asynccontextmanager
 from typing import Optional
 
-from sqlalchemy import text
+from sqlalchemy import event, text
 from sqlalchemy.ext.asyncio import (
     AsyncSession,
     async_sessionmaker,
@@ -197,17 +198,50 @@ class TokenUsageDBConnector(metaclass=SingletonMeta):
 
         # 创建异步引擎（Token 记录连接池较小，增加连接超时防止慢 MySQL 拖垮主服务）
         # 4 workers × (pool_size=1 + max_overflow=2) = 12
+        # 🔑 TCP keepalive：与 AsyncDatabaseConnector（73f2156）同源风险——aiomysql 无查询
+        # 级读超时，池中死连接会让 Token 落库黑洞挂死。pool_recycle 同步降为 300，
+        # 赶在防火墙空闲回收窗口（常见 5-15min）前换血。
         self.engine = create_async_engine(
             self.db_url,
             connect_args={**params, "connect_timeout": 3},
             pool_size=1,
             max_overflow=2,
             pool_timeout=5,
-            pool_recycle=3600,
+            pool_recycle=300,
             pool_pre_ping=True,
             echo=False,
         )
 
+        # 每个新连接补齐 TCP keepalive 参数（连接建立后才能拿到 raw socket）
+        @event.listens_for(self.engine.sync_engine, "connect")
+        def tune_keepalive(dbapi_connection, connection_record):
+            import socket as _socket
+            try:
+                # SQLAlchemy 2.x 异步方言把 aiomysql 连接包在
+                # AsyncAdapt_aiomysql_connection._connection 里；老版本/裸 aiomysql
+                # 则直接挂 _writer。两级都探测。
+                inner = getattr(dbapi_connection, "_connection", dbapi_connection)
+                writer = getattr(inner, "_writer", None)
+                transport = getattr(writer, "transport", None)
+                raw_sock = transport.get_extra_info("socket") if transport else None
+                if raw_sock is None:
+                    return
+                raw_sock.setsockopt(_socket.SOL_SOCKET, _socket.SO_KEEPALIVE, 1)
+                if sys.platform == "win32":
+                    # Windows: SIO_KEEPALIVE_VALS = (on/off, idle ms, interval ms)
+                    raw_sock.ioctl(_socket.SIO_KEEPALIVE_VALS, (1, 30000, 10000))
+                else:
+                    # Linux: 空闲 30s 发首个探测，每 10s 一次，3 次无回应判死（约 60s 暴露）
+                    if hasattr(_socket, "TCP_KEEPIDLE"):
+                        raw_sock.setsockopt(_socket.IPPROTO_TCP, _socket.TCP_KEEPIDLE, 30)
+                    if hasattr(_socket, "TCP_KEEPINTVL"):
+                        raw_sock.setsockopt(_socket.IPPROTO_TCP, _socket.TCP_KEEPINTVL, 10)
+                    if hasattr(_socket, "TCP_KEEPCNT"):
+                        raw_sock.setsockopt(_socket.IPPROTO_TCP, _socket.TCP_KEEPCNT, 3)
+            except Exception as e:
+                # keepalive 调优失败不阻断连接创建（回退内核默认）
+                SYLogger.warning(f"TCP keepalive 调优失败（回退默认）: {e}")
+
         # 注册 SQL 日志拦截器
         from sycommon.logging.async_sql_logger import AsyncSQLTraceLogger
         AsyncSQLTraceLogger.setup_sql_logging(self.engine)

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/src/sycommon/heartbeat_process/heartbeat_process_worker.py

@@ -178,6 +178,9 @@ class HeartbeatProcessWorker:
                 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:

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/src/sycommon/middleware/traceid.py

@@ -68,7 +68,7 @@ def setup_trace_id_handler(app):
         token = SYLogger.set_trace_id(trace_id)
         # 🔒 白名单过滤：Authorization/Cookie/SYT_TOKEN 等凭证 header 不进
         # 日志上下文，防止下游任何日志路径把凭证打到日志。
-        header_token = SYLogger.set_headers(_filtered_headers(request.headers.raw))
+        header_token = SYLogger.set_headers(request.headers.raw)
 
         # 获取请求参数
         query_params = dict(request.query_params)

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/src/sycommon/models/base_http.py

@@ -1,4 +1,6 @@
 from typing import TypeVar, Any, Generic
+import warnings
+
 from pydantic import BaseModel, Field
 from fastapi.responses import JSONResponse
 from fastapi import status
@@ -8,7 +10,11 @@ T = TypeVar('T')
 
 
 class BaseResponseModel(BaseModel, Generic[T]):
-    """基础响应模型，支持自定义状态码"""
+    """基础响应模型，支持自定义状态码
+
+    注意:code 默认 0 是旧版 0/1 业务码的兼容默认值,新代码请走
+    ok()/fail()(code=200/500)。默认值暂不改,避免破坏旧接口反序列化。
+    """
     code: int = Field(default=0, description="业务响应码，默认0成功，1失败，支持自定义")
     message: str | None = Field(default=None, description="业务响应信息")
     success: bool = Field(default=True, description="请求是否成功")
@@ -20,6 +26,23 @@ class BaseResponseModel(BaseModel, Generic[T]):
         from_attributes = True
 
 
+# =====================================================================
+# 【Deprecated】旧版 0/1 业务码方式 —— 未来将移除,请勿在新代码中使用。
+#
+# 新代码请用下方的 ok() / fail()(HTTP 语义:成功 code=200 / 失败 code=500,
+# HTTP status 与业务码一致,success 由 2xx 推导)。
+# =====================================================================
+
+
+def _deprecate_01_style(name: str) -> None:
+    warnings.warn(
+        f"sycommon.models.base_http.{name} 已废弃(0/1 业务码方式),"
+        f"请改用 ok()/fail()(HTTP 语义 code=200/500);未来版本将移除。",
+        DeprecationWarning,
+        stacklevel=3,
+    )
+
+
 def build_response_content(
     data: T | Any = None,
     code: int = 0,
@@ -59,7 +82,8 @@ def create_response(
     message: str = None,
     status_code: int = status.HTTP_200_OK
 ) -> JSONResponse:
-    """创建完整响应，支持自定义业务状态码"""
+    """【Deprecated】创建完整响应,支持自定义业务状态码 —— 改用 http_response()"""
+    _deprecate_01_style("create_response")
     content = build_response_content(data=data, code=code, message=message)
     return JSONResponse(
         content=content,
@@ -68,7 +92,8 @@ def create_response(
 
 
 def success_response(data: T | Any = None, code: int = 0, message: str = None) -> JSONResponse:
-    """快捷创建成功响应（code=0, success=True）"""
+    """【Deprecated】快捷创建成功响应(code=0, success=True) —— 改用 ok()"""
+    _deprecate_01_style("success_response")
     return create_response(data=data, code=code, message=message)
 
 
@@ -78,7 +103,8 @@ def error_response(
     data: T | Any = None,
     status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR
 ) -> JSONResponse:
-    """快捷创建错误响应，支持自定义错误码（如200）"""
+    """【Deprecated】快捷创建错误响应(code=1) —— 改用 fail()"""
+    _deprecate_01_style("error_response")
     return create_response(
         data=data,
         code=code,
@@ -88,7 +114,8 @@ def error_response(
 
 
 def success_content(data: T | Any = None) -> dict:
-    """构建成功响应内容字典"""
+    """【Deprecated】构建成功响应内容字典(code=0) —— 改用 ok()"""
+    _deprecate_01_style("success_content")
     return build_response_content(data=data)
 
 
@@ -97,7 +124,8 @@ def error_content(
     code: int = 1,
     data: T | Any = None
 ) -> dict:
-    """构建错误响应内容字典，支持自定义错误码"""
+    """【Deprecated】构建错误响应内容字典(code=1) —— 改用 fail()"""
+    _deprecate_01_style("error_content")
     return build_response_content(data=data, code=code, message=message)
 
 
@@ -107,7 +135,7 @@ def error_content(
 # 与上面 0/1 业务码的区别：code 直接用 HTTP 状态码语义——
 #   成功 code=200 / 失败 code=500，HTTP status 同步对应（200 / 500），
 # success 由 code 是否为 2xx 推导。不再用 0/1 代表成功失败。
-# 旧函数保留兼容，新项目请用 ok() / fail()。
+# 旧函数已标记 Deprecated(调用即抛 DeprecationWarning),未来版本移除。
 # =====================================================================
 
 

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/src/sycommon/notice/uvicorn_monitor.py

@@ -55,6 +55,9 @@ async def send_wechat_markdown_msg(
 ) -> Optional[dict]:
     """
     异步发送企业微信Markdown格式的WebHook消息
+
+    失败（网络异常/非0 errcode）时等 2 秒重试一次，
+    避免网络瞬时抖动导致告警丢失（例如只收到"恢复"没收到"断开"）。
     """
     # 构造请求体（Markdown格式）
     payload = {
@@ -64,26 +67,34 @@ async def send_wechat_markdown_msg(
         }
     }
 
-    try:
-        # 使用 json 参数自动处理序列化和 Content-Type
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                url=webhook,
-                json=payload,
-                timeout=aiohttp.ClientTimeout(total=10)
-            ) as response:
-                response_data = await response.json()
-
-                if response.status == 200 and response_data.get("errcode") == 0:
-                    SYLogger.info(f"消息发送成功: {response_data}")
-                    return response_data
-                else:
-                    SYLogger.warning(
-                        f"消息发送失败 - 状态码: {response.status}, 响应: {response_data}")
-                    return None
-    except Exception as e:
-        SYLogger.error(f"发送企业微信消息异常: {str(e)}")
-        return None
+    max_attempts = 2
+    for attempt in range(1, max_attempts + 1):
+        try:
+            # 使用 json 参数自动处理序列化和 Content-Type
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    url=webhook,
+                    json=payload,
+                    timeout=aiohttp.ClientTimeout(total=10)
+                ) as response:
+                    response_data = await response.json()
+
+                    if response.status == 200 and response_data.get("errcode") == 0:
+                        SYLogger.info(f"消息发送成功: {response_data}")
+                        return response_data
+                    else:
+                        SYLogger.warning(
+                            f"消息发送失败 - 状态码: {response.status}, 响应: {response_data}")
+                        if attempt < max_attempts:
+                            await asyncio.sleep(2)
+                            continue
+                        return None
+        except Exception as e:
+            SYLogger.error(f"发送企业微信消息异常: {str(e)}")
+            if attempt < max_attempts:
+                await asyncio.sleep(2)
+                continue
+            return None
 
 
 async def send_webhook(error_info: dict = None, webhook: str = None):

{sycommon_python_lib-0.2.10a3 → sycommon_python_lib-0.2.10a5}/src/sycommon/synacos/nacos_client_base.py

@@ -88,6 +88,9 @@ class NacosClientBase:
                     server_addresses=register_ip,
                     namespace=namespace_id
                 )
+                # SDK 默认单请求超时仅 3 秒，网络/DNS 抖动即抛
+                # "All server are not available"，放宽到 10 秒
+                self.nacos_client.set_options(default_timeout=10)
                 SYLogger.info("nacos:客户端初始化成功")
                 self._client_initialized = True
                 return True
@@ -120,6 +123,9 @@ class NacosClientBase:
                         server_addresses=register_ip,
                         namespace=namespace_id
                     )
+                    # SDK 默认单请求超时仅 3 秒，网络/DNS 抖动即抛
+                    # "All server are not available"，放宽到 10 秒
+                    self.nacos_client.set_options(default_timeout=10)
 
                     if self._verify_client_connection():
                         self._client_initialized = True