sycommon-python-lib 0.2.0b16__tar.gz → 0.2.0b18__tar.gz

{sycommon_python_lib-0.2.0b16 → sycommon_python_lib-0.2.0b18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.0b16
+Version: 0.2.0b18
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.0b16 → sycommon_python_lib-0.2.0b18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.0b16"
+version = "0.2.0b18"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.0b16 → sycommon_python_lib-0.2.0b18}/src/sycommon/database/async_base_db_service.py

@@ -8,13 +8,7 @@ from sycommon.logging.kafka_log import SYLogger
 class AsyncBaseDBService(metaclass=SingletonMeta):
     """数据库操作基础服务类，封装异步会话管理功能"""
 
-    _initialized: bool = False
-
     def __init__(self):
-        if AsyncBaseDBService._initialized:
-            return
-        AsyncBaseDBService._initialized = True
-
         # 获取异步引擎 (假设 DatabaseService.engine() 返回的是 AsyncEngine)
         self.engine = AsyncDatabaseService.engine()
 

{sycommon_python_lib-0.2.0b16 → sycommon_python_lib-0.2.0b18}/src/sycommon/database/base_db_service.py

@@ -8,13 +8,7 @@ from sycommon.logging.kafka_log import SYLogger
 class BaseDBService(metaclass=SingletonMeta):
     """数据库操作基础服务类，封装会话管理功能"""
 
-    _initialized: bool = False
-
     def __init__(self):
-        if BaseDBService._initialized:
-            return
-        BaseDBService._initialized = True
-
         self.engine = DatabaseService.engine()
         self.Session = sessionmaker(bind=self.engine)
 

{sycommon_python_lib-0.2.0b16 → sycommon_python_lib-0.2.0b18}/src/sycommon/llm/get_llm.py

@@ -62,7 +62,7 @@ def get_llm(
         )
         ```
     """
-    if not model:
+    if not model or model == "Qwen2.5-72B":
         # model = "Qwen2.5-72B"
         model = "Qwen3.5-122B-A10B"
         kwargs["presence_penalty"] = 0

{sycommon_python_lib-0.2.0b16 → sycommon_python_lib-0.2.0b18}/src/sycommon/notice/uvicorn_monitor.py

@@ -9,6 +9,46 @@ from sycommon.config.Config import Config
 from sycommon.logging.kafka_log import SYLogger
 
 
+def get_webhook() -> Optional[str]:
+    """
+    获取企业微信 WebHook 配置
+
+    支持两种配置格式：
+    1. 字符串格式（旧版）：
+       llm:
+         WebHook: https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx
+
+    2. 对象格式（新版，支持启用开关）：
+       llm:
+         WebHook:
+           enabled: true
+           url: https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx
+    """
+    try:
+        config = Config().config
+        webhook_config = config.get('llm', {}).get('WebHook')
+
+        if webhook_config is None:
+            return None
+
+        # 字符串格式（旧版兼容）
+        if isinstance(webhook_config, str):
+            return webhook_config
+
+        # 对象格式（新版）
+        if isinstance(webhook_config, dict):
+            # 检查是否启用
+            if not webhook_config.get('enabled', True):
+                SYLogger.debug("企业微信 WebHook 已禁用")
+                return None
+            return webhook_config.get('url')
+
+        return None
+    except Exception as e:
+        SYLogger.warning(f"读取 WebHook 配置失败: {str(e)}")
+        return None
+
+
 async def send_wechat_markdown_msg(
     content: str,
     webhook: str = None
@@ -55,8 +95,7 @@ async def send_webhook(error_info: dict = None, webhook: str = None):
         config = Config().config
         service_name = config.get('Name', "未知服务")
         env = config.get('Nacos', {}).get('namespaceId', '未知环境')
-        # 注意：这里使用了大写开头的 WebHook，请确保配置文件中键名一致
-        webHook = config.get('llm', {}).get('WebHook')
+        webHook = get_webhook()
     except Exception as e:
         service_name = "未知服务"
         env = "未知环境"
@@ -186,3 +225,122 @@ def run(*args, webhook: str = None, **kwargs):
 
             # 只有确实有错误时才以状态码 1 退出
             sys.exit(1)
+
+
+async def send_mq_disconnect_alert(
+    error_msg: str,
+    host: str = None,
+    app_name: str = None,
+    disconnect_count: int = 0,
+    reconnect_attempts: int = 0,
+    is_recovered: bool = False
+) -> Optional[dict]:
+    """
+    发送 MQ 连接断开告警
+
+    :param error_msg: 错误信息
+    :param host: RabbitMQ 主机地址
+    :param app_name: 应用名称（MQ连接名）
+    :param disconnect_count: 累计断开次数
+    :param reconnect_attempts: 重连尝试次数
+    :param is_recovered: 是否已恢复
+    :return: 发送结果
+    """
+    try:
+        config = Config().config
+        service_name = config.get('Name', "未知服务")
+        env = config.get('Nacos', {}).get('namespaceId', '未知环境')
+    except Exception:
+        service_name = "未知服务"
+        env = "未知环境"
+
+    webhook = get_webhook()
+    if not webhook:
+        SYLogger.debug("未配置企业微信 WebHook，跳过 MQ 断连告警")
+        return None
+
+    alert_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    # 显示服务名和应用名
+    display_name = f"{service_name}" + (f" ({app_name})" if app_name else "")
+
+    if is_recovered:
+        # 恢复通知
+        markdown_content = f"""### {display_name} RabbitMQ 连接已恢复 ✅
+> 环境: <font color="info">{env}</font>
+> 时间: <font color="comment">{alert_time}</font>
+> 节点: <font color="comment">{host or '未知'}</font>
+> 恢复前重试次数: {reconnect_attempts}
+> 本次断开次数: {disconnect_count}"""
+    else:
+        # 断开告警
+        markdown_content = f"""### {display_name} RabbitMQ 连接断开告警 🚨
+> 环境: <font color="warning">{env}</font>
+> 时间: <font color="comment">{alert_time}</font>
+> 节点: <font color="comment">{host or '未知'}</font>
+> 累计断开次数: <font color="danger">{disconnect_count}</font>
+> 重连尝试: {reconnect_attempts} 次
+> 错误信息: <font color="danger">{error_msg}</font>"""
+
+    return await send_wechat_markdown_msg(
+        content=markdown_content,
+        webhook=webhook
+    )
+
+
+async def send_nacos_disconnect_alert(
+    error_msg: str,
+    service_name: str = None,
+    host: str = None,
+    disconnect_count: int = 0,
+    fail_count: int = 0,
+    is_recovered: bool = False
+) -> Optional[dict]:
+    """
+    发送 Nacos 连接断开告警
+
+    :param error_msg: 错误信息
+    :param service_name: 服务名称
+    :param host: 服务地址
+    :param disconnect_count: 累计断开次数
+    :param fail_count: 连续失败次数
+    :param is_recovered: 是否已恢复
+    :return: 发送结果
+    """
+    try:
+        config = Config().config
+        display_service_name = config.get('Name', "未知服务")
+        env = config.get('Nacos', {}).get('namespaceId', '未知环境')
+    except Exception:
+        display_service_name = "未知服务"
+        env = "未知环境"
+
+    webhook = get_webhook()
+    if not webhook:
+        SYLogger.debug("未配置企业微信 WebHook，跳过 Nacos 断连告警")
+        return None
+
+    alert_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    # 显示服务名
+    display_name = service_name or display_service_name
+
+    if is_recovered:
+        # 恢复通知
+        markdown_content = f"""### {display_name} Nacos 心跳已恢复 ✅
+> 环境: <font color="info">{env}</font>
+> 时间: <font color="comment">{alert_time}</font>
+> 服务地址: <font color="comment">{host or '未知'}</font>
+> 累计断开次数: {disconnect_count}"""
+    else:
+        # 断开告警
+        markdown_content = f"""### {display_name} Nacos 心跳失败告警 🚨
+> 环境: <font color="warning">{env}</font>
+> 时间: <font color="comment">{alert_time}</font>
+> 服务地址: <font color="comment">{host or '未知'}</font>
+> 累计断开次数: <font color="danger">{disconnect_count}</font>
+> 连续失败: {fail_count} 次
+> 错误信息: <font color="danger">{error_msg}</font>"""
+
+    return await send_wechat_markdown_msg(
+        content=markdown_content,
+        webhook=webhook
+    )

{sycommon_python_lib-0.2.0b16 → sycommon_python_lib-0.2.0b18}/src/sycommon/rabbitmq/rabbitmq_pool.py

@@ -4,6 +4,7 @@ from typing import Optional, List, Tuple
 from aio_pika import connect_robust
 from aio_pika.abc import AbstractChannel, AbstractRobustConnection
 from sycommon.logging.kafka_log import SYLogger
+from sycommon.notice.uvicorn_monitor import send_mq_disconnect_alert
 
 logger = SYLogger
 
@@ -18,6 +19,15 @@ class RabbitMQConnectionPool:
     3. 增强连接探活与重建机制。
     """
 
+    # 心跳重试配置
+    HEARTBEAT_RETRY_COUNT = 3  # 心跳失败重试次数
+    HEARTBEAT_RETRY_INTERVAL = 10  # 心跳重试间隔（秒）
+
+    # 告警状态（类级别，用于跨实例统计）
+    _alert_sent: bool = False  # 是否已发送断连告警
+    _reconnect_attempts: int = 0  # 当前重连尝试次数
+    _disconnect_count: int = 0  # 累计断开次数
+
     def __init__(
         self,
         hosts: List[str],
@@ -59,13 +69,84 @@ class RabbitMQConnectionPool:
         self._initialized = False
         self._is_shutdown = False
 
+        # 心跳重试计数器
+        self._heartbeat_fail_count = 0
+
     async def is_alive(self) -> bool:
-        """对外暴露的连接存活状态"""
+        """对外暴露的连接存活状态（带心跳重试机制）
+
+        心跳检测失败时不会立即判定为断开，而是重试3次后才断开。
+        """
         if self._is_shutdown:
             return False
         if not self._initialized:
             return False
-        return self._connection is not None and not self._connection.is_closed
+
+        # 基础连接检查
+        if self._connection is None or self._connection.is_closed:
+            self._heartbeat_fail_count += 1
+            logger.warning(
+                f"⚠️ [HEARTBEAT] 连接已断开 (失败计数: {self._heartbeat_fail_count}/{self.HEARTBEAT_RETRY_COUNT})"
+            )
+            if self._heartbeat_fail_count >= self.HEARTBEAT_RETRY_COUNT:
+                logger.error("❌ [HEARTBEAT] 心跳重试次数已达上限，判定连接死亡")
+                # 发送断连告警（仅发送一次）
+                if not self._alert_sent:
+                    self._alert_sent = True
+                    self._disconnect_count += 1
+                    asyncio.create_task(send_mq_disconnect_alert(
+                        error_msg="心跳检测连续失败，连接已断开",
+                        host=self._current_host,
+                        app_name=self.app_name,
+                        disconnect_count=self._disconnect_count,
+                        reconnect_attempts=self._reconnect_attempts
+                    ))
+                return False
+            # 未达上限，暂时认为存活（等待重试）
+            return True
+
+        # 内部通道探活检查
+        try:
+            if self._internal_channel is None or self._internal_channel.is_closed:
+                self._internal_channel = await self._connection.channel()
+            # 探活成功，重置失败计数器
+            self._heartbeat_fail_count = 0
+            # 如果之前发送过告警，现在恢复，发送恢复通知
+            if self._alert_sent:
+                self._alert_sent = False
+                saved_reconnect_attempts = self._reconnect_attempts
+                saved_disconnect_count = self._disconnect_count
+                self._reconnect_attempts = 0
+                asyncio.create_task(send_mq_disconnect_alert(
+                    error_msg="连接已恢复",
+                    host=self._current_host,
+                    app_name=self.app_name,
+                    disconnect_count=saved_disconnect_count,
+                    reconnect_attempts=saved_reconnect_attempts,
+                    is_recovered=True
+                ))
+            return True
+        except Exception as e:
+            self._heartbeat_fail_count += 1
+            logger.warning(
+                f"⚠️ [HEARTBEAT] 连接探活失败: {e} (失败计数: {self._heartbeat_fail_count}/{self.HEARTBEAT_RETRY_COUNT})"
+            )
+            if self._heartbeat_fail_count >= self.HEARTBEAT_RETRY_COUNT:
+                logger.error("❌ [HEARTBEAT] 心跳重试次数已达上限，判定连接死亡")
+                # 发送断连告警（仅发送一次）
+                if not self._alert_sent:
+                    self._alert_sent = True
+                    self._disconnect_count += 1
+                    asyncio.create_task(send_mq_disconnect_alert(
+                        error_msg=str(e),
+                        host=self._current_host,
+                        app_name=self.app_name,
+                        disconnect_count=self._disconnect_count,
+                        reconnect_attempts=self._reconnect_attempts
+                    ))
+                return False
+            # 未达上限，暂时认为存活（等待重试）
+            return True
 
     async def _cleanup_resources(self):
         """彻底清理资源"""
@@ -135,6 +216,7 @@ class RabbitMQConnectionPool:
 
                 for host in retry_hosts:
                     self._current_host = host
+                    self._reconnect_attempts += 1
                     try:
                         self._connection = await self._create_connection_impl(host)
                         self._initialized = True
@@ -148,6 +230,24 @@ class RabbitMQConnectionPool:
                     self._initialized = False
                     raise ConnectionError("所有 RabbitMQ 节点连接失败") from last_error
 
+                # 重连成功，发送恢复通知
+                if self._alert_sent:
+                    self._alert_sent = False
+                    saved_reconnect_attempts = self._reconnect_attempts
+                    saved_disconnect_count = self._disconnect_count
+                    self._reconnect_attempts = 0
+                    asyncio.create_task(send_mq_disconnect_alert(
+                        error_msg="连接重连成功",
+                        host=self._current_host,
+                        app_name=self.app_name,
+                        disconnect_count=saved_disconnect_count,
+                        reconnect_attempts=saved_reconnect_attempts,
+                        is_recovered=True
+                    ))
+
+            # 连接正常，重置心跳失败计数器
+            self._heartbeat_fail_count = 0
+
             return self._connection
 
     async def init_pools(self):

{sycommon_python_lib-0.2.0b16 → sycommon_python_lib-0.2.0b18}/src/sycommon/synacos/nacos_heartbeat_manager.py

@@ -1,3 +1,4 @@
+import asyncio
 import threading
 import time
 from sycommon.logging.kafka_log import SYLogger
@@ -5,9 +6,42 @@ from sycommon.synacos.nacos_client_base import NacosClientBase
 from sycommon.synacos.nacos_service_registration import NacosServiceRegistration
 
 
+def send_nacos_alert_sync(
+    error_msg: str,
+    service_name: str = None,
+    host: str = None,
+    disconnect_count: int = 0,
+    fail_count: int = 0,
+    is_recovered: bool = False
+):
+    """同步方式发送 Nacos 告警（用于在线程中调用）"""
+    try:
+        # 创建新的事件循环
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            from sycommon.notice.uvicorn_monitor import send_nacos_disconnect_alert
+            loop.run_until_complete(send_nacos_disconnect_alert(
+                error_msg=error_msg,
+                service_name=service_name,
+                host=host,
+                disconnect_count=disconnect_count,
+                fail_count=fail_count,
+                is_recovered=is_recovered
+            ))
+        finally:
+            loop.close()
+    except Exception as e:
+        SYLogger.warning(f"发送 Nacos 告警失败: {e}")
+
+
 class NacosHeartbeatManager:
     """Nacos心跳管理类 - 负责心跳发送和监控"""
 
+    # 告警状态（类级别）
+    _alert_sent: bool = False  # 是否已发送断连告警
+    _disconnect_count: int = 0  # 累计断开次数
+
     def __init__(self, client_base: NacosClientBase, registration: NacosServiceRegistration, heartbeat_interval: int = 15):
         self.client_base = client_base
         self.registration = registration
@@ -75,8 +109,20 @@ class NacosHeartbeatManager:
                         SYLogger.info(
                             f"nacos:心跳发送成功 - 间隔: {self.heartbeat_interval}秒"
                         )
+                        # 恢复后发送通知
+                        if self._alert_sent:
+                            self._alert_sent = False
+                            send_nacos_alert_sync(
+                                error_msg="心跳恢复正常",
+                                service_name=self.registration.service_name,
+                                host=f"{self.registration.real_ip}:{self.registration.port}",
+                                disconnect_count=self._disconnect_count,
+                                fail_count=0,
+                                is_recovered=True
+                            )
                     else:
                         consecutive_fail += 1
+                        self._heartbeat_fail_count += 1
                         SYLogger.warning(
                             f"nacos:心跳发送失败 - 连续失败: {consecutive_fail}次"
                         )
@@ -85,11 +131,38 @@ class NacosHeartbeatManager:
                             self.client_base.reconnect_nacos_client()
                             consecutive_fail = 0
 
+                        # 连续失败3次后发送告警（仅发送一次）
+                        if consecutive_fail >= 3 and not self._alert_sent:
+                            self._alert_sent = True
+                            self._disconnect_count += 1
+                            send_nacos_alert_sync(
+                                error_msg=f"心跳连续失败{consecutive_fail}次",
+                                service_name=self.registration.service_name,
+                                host=f"{self.registration.real_ip}:{self.registration.port}",
+                                disconnect_count=self._disconnect_count,
+                                fail_count=consecutive_fail,
+                                is_recovered=False
+                            )
+
             except Exception as e:
                 consecutive_fail += 1
+                self._heartbeat_fail_count += 1
                 SYLogger.error(
                     f"nacos:心跳异常: {str(e)}, 连续失败: {consecutive_fail}次")
 
+                # 异常情况下也发送告警
+                if consecutive_fail >= 3 and not self._alert_sent:
+                    self._alert_sent = True
+                    self._disconnect_count += 1
+                    send_nacos_alert_sync(
+                        error_msg=f"心跳异常: {str(e)}",
+                        service_name=self.registration.service_name,
+                        host=f"{self.registration.real_ip}:{self.registration.port}",
+                        disconnect_count=self._disconnect_count,
+                        fail_count=consecutive_fail,
+                        is_recovered=False
+                    )
+
             # 计算剩余等待时间，确保心跳间隔精确
             elapsed = time.time() - heartbeat_start_time
             remaining_wait = max(0, self.heartbeat_interval - elapsed)

{sycommon_python_lib-0.2.0b16 → sycommon_python_lib-0.2.0b18}/src/sycommon/synacos/nacos_service_discovery.py

@@ -1,13 +1,44 @@
+import asyncio
 import threading
+import time
 from typing import List, Dict
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.synacos.nacos_client_base import NacosClientBase
 from sycommon.synacos.nacos_service_registration import NacosServiceRegistration
 
 
+def send_nacos_service_alert_sync(
+    error_msg: str,
+    service_name: str = None,
+    host: str = None,
+    is_service_down: bool = False
+):
+    """同步方式发送 Nacos 服务告警（用于在线程中调用）"""
+    try:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            from sycommon.notice.uvicorn_monitor import send_nacos_disconnect_alert
+            loop.run_until_complete(send_nacos_disconnect_alert(
+                error_msg=error_msg,
+                service_name=service_name,
+                host=host,
+                disconnect_count=1 if is_service_down else 0,
+                fail_count=1,
+                is_recovered=False
+            ))
+        finally:
+            loop.close()
+    except Exception as e:
+        SYLogger.warning(f"发送 Nacos 服务告警失败: {e}")
+
+
 class NacosServiceDiscovery:
     """Nacos服务发现类 - 负责服务实例发现和轮询"""
 
+    # 告警状态
+    _service_alert_sent: bool = False
+
     def __init__(self, client_base: NacosClientBase):
         self.client_base = client_base
 
@@ -137,6 +168,15 @@ class NacosServiceDiscovery:
                         registration.registered = current_registered
                         if not current_registered:
                             SYLogger.warning("nacos:服务实例未注册，触发单次重新注册")
+                            # 发送服务不可用告警
+                            if not self._service_alert_sent:
+                                self._service_alert_sent = True
+                                send_nacos_service_alert_sync(
+                                    error_msg="服务实例在Nacos中已失效",
+                                    service_name=registration.service_name,
+                                    host=f"{registration.real_ip}:{registration.port}",
+                                    is_service_down=True
+                                )
                             retry_thread = threading.Thread(
                                 target=registration.register,
                                 args=(True,),
@@ -146,7 +186,21 @@ class NacosServiceDiscovery:
                             retry_thread.start()
                         else:
                             SYLogger.info("nacos:服务实例已注册，触发单次验证")
+                            # 恢复后重置告警状态
+                            if self._service_alert_sent:
+                                self._service_alert_sent = False
+                                # 发送恢复通知
+                                send_nacos_service_alert_sync(
+                                    error_msg="服务实例已恢复注册",
+                                    service_name=registration.service_name,
+                                    host=f"{registration.real_ip}:{registration.port}",
+                                    is_service_down=False
+                                )
                             registration.verify_registration()
+                    else:
+                        # 服务正常，重置告警状态
+                        if self._service_alert_sent and current_registered:
+                            self._service_alert_sent = False
 
                 self.client_base._shutdown_event.wait(check_interval)
 

{sycommon_python_lib-0.2.0b16 → sycommon_python_lib-0.2.0b18}/src/sycommon_python_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.0b16
+Version: 0.2.0b18
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown