sycommon-python-lib 0.2.0b21__tar.gz → 0.2.0b23__tar.gz

{sycommon_python_lib-0.2.0b21 → sycommon_python_lib-0.2.0b23}/PKG-INFO

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

{sycommon_python_lib-0.2.0b21 → sycommon_python_lib-0.2.0b23}/pyproject.toml

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

{sycommon_python_lib-0.2.0b21 → sycommon_python_lib-0.2.0b23}/src/sycommon/rabbitmq/rabbitmq_pool.py

@@ -71,11 +71,13 @@ class RabbitMQConnectionPool:
         self._alert_sent: bool = False  # 是否已发送断连告警
         self._reconnect_attempts: int = 0  # 当前重连尝试次数
         self._disconnect_count: int = 0  # 累计断开次数
+        self._consecutive_success: int = 0  # 连续成功次数，用于确认恢复
 
     async def is_alive(self) -> bool:
         """对外暴露的连接存活状态（带心跳重试机制）
 
         心跳检测失败时不会立即判定为断开，而是重试3次后才断开。
+        恢复通知需要连续成功3次确认，避免短暂恢复后又断开的波动情况。
         """
         if self._is_shutdown:
             return False
@@ -85,6 +87,7 @@ class RabbitMQConnectionPool:
         # 基础连接检查
         if self._connection is None or self._connection.is_closed:
             self._heartbeat_fail_count += 1
+            self._consecutive_success = 0  # 失败时重置连续成功计数
             logger.warning(
                 f"⚠️ [HEARTBEAT] 连接已断开 (失败计数: {self._heartbeat_fail_count}/{self.HEARTBEAT_RETRY_COUNT})"
             )
@@ -94,6 +97,9 @@ class RabbitMQConnectionPool:
                 if not self._alert_sent:
                     self._alert_sent = True
                     self._disconnect_count += 1
+                    logger.warning(
+                        f"📊 [MQ_ALERT] 发送断连告警，累计断开: {self._disconnect_count}次，重连尝试: {self._reconnect_attempts}次"
+                    )
                     asyncio.create_task(send_mq_disconnect_alert(
                         error_msg="心跳检测连续失败，连接已断开",
                         host=self._current_host,
@@ -109,14 +115,19 @@ class RabbitMQConnectionPool:
         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._consecutive_success += 1
+
+            # 如果之前发送过告警，心跳成功一次即发送恢复通知
+            if self._alert_sent and self._consecutive_success >= 1:
                 self._alert_sent = False
                 saved_reconnect_attempts = self._reconnect_attempts
                 saved_disconnect_count = self._disconnect_count
                 self._reconnect_attempts = 0
+                logger.info(
+                    f"✅ [MQ_RECOVERED] 连接已稳定恢复（连续成功{self._consecutive_success}次），发送恢复通知"
+                )
                 asyncio.create_task(send_mq_disconnect_alert(
                     error_msg="连接已恢复",
                     host=self._current_host,
@@ -128,6 +139,7 @@ class RabbitMQConnectionPool:
             return True
         except Exception as e:
             self._heartbeat_fail_count += 1
+            self._consecutive_success = 0  # 异常时重置连续成功计数
             logger.warning(
                 f"⚠️ [HEARTBEAT] 连接探活失败: {e} (失败计数: {self._heartbeat_fail_count}/{self.HEARTBEAT_RETRY_COUNT})"
             )
@@ -137,6 +149,9 @@ class RabbitMQConnectionPool:
                 if not self._alert_sent:
                     self._alert_sent = True
                     self._disconnect_count += 1
+                    logger.warning(
+                        f"📊 [MQ_ALERT] 发送断连告警（异常），累计断开: {self._disconnect_count}次，重连尝试: {self._reconnect_attempts}次"
+                    )
                     asyncio.create_task(send_mq_disconnect_alert(
                         error_msg=str(e),
                         host=self._current_host,
@@ -230,12 +245,17 @@ class RabbitMQConnectionPool:
                     self._initialized = False
                     raise ConnectionError("所有 RabbitMQ 节点连接失败") from last_error
 
-                # 重连成功，发送恢复通知
+                # 重连成功
+                self._consecutive_success = 1  # 重连成功算第1次成功
+                # 发送恢复通知（重连成功后直接发送，因为是主动重建连接）
                 if self._alert_sent:
                     self._alert_sent = False
                     saved_reconnect_attempts = self._reconnect_attempts
                     saved_disconnect_count = self._disconnect_count
                     self._reconnect_attempts = 0
+                    logger.info(
+                        f"✅ [MQ_RECONNECT_OK] 重连成功，发送恢复通知，累计断开: {saved_disconnect_count}次"
+                    )
                     asyncio.create_task(send_mq_disconnect_alert(
                         error_msg="连接重连成功",
                         host=self._current_host,

{sycommon_python_lib-0.2.0b21 → sycommon_python_lib-0.2.0b23}/src/sycommon/synacos/nacos_heartbeat_manager.py

@@ -15,13 +15,14 @@ def send_nacos_alert_sync(
     is_recovered: bool = False
 ):
     """同步方式发送 Nacos 告警（用于在线程中调用）"""
+    alert_type = "恢复" if is_recovered else "断开"
     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(
+            result = loop.run_until_complete(send_nacos_disconnect_alert(
                 error_msg=error_msg,
                 service_name=service_name,
                 host=host,
@@ -29,10 +30,14 @@ def send_nacos_alert_sync(
                 fail_count=fail_count,
                 is_recovered=is_recovered
             ))
+            if result:
+                SYLogger.info(f"Nacos {alert_type}告警发送成功")
+            else:
+                SYLogger.warning(f"Nacos {alert_type}告警发送返回空结果")
         finally:
             loop.close()
     except Exception as e:
-        SYLogger.warning(f"发送 Nacos 告警失败: {e}")
+        SYLogger.error(f"发送 Nacos {alert_type}告警失败: {e}")
 
 
 class NacosHeartbeatManager:
@@ -41,6 +46,7 @@ class NacosHeartbeatManager:
     # 告警状态（类级别）
     _alert_sent: bool = False  # 是否已发送断连告警
     _disconnect_count: int = 0  # 累计断开次数
+    _alert_fail_count: int = 0  # 发送告警时的连续失败次数（用于恢复通知）
 
     def __init__(self, client_base: NacosClientBase, registration: NacosServiceRegistration, heartbeat_interval: int = 15):
         self.client_base = client_base
@@ -89,6 +95,7 @@ class NacosHeartbeatManager:
         )
 
         consecutive_fail = 0
+        consecutive_success = 0  # 连续成功次数，用于确认恢复
 
         while not self.client_base._shutdown_event.is_set():
             # 记录本次心跳开始时间，用于精确计算剩余等待时间
@@ -101,17 +108,21 @@ class NacosHeartbeatManager:
                     SYLogger.warning(
                         f"nacos:服务未注册，跳过心跳 - 线程ID: {thread_ident}")
                     consecutive_fail = 0
+                    consecutive_success = 0
                 else:
                     success = self.send_heartbeat()
                     if success:
                         consecutive_fail = 0
+                        consecutive_success += 1
                         self._last_heartbeat_time = time.time()
                         SYLogger.info(
-                            f"nacos:心跳发送成功 - 间隔: {self.heartbeat_interval}秒"
+                            f"nacos:心跳发送成功 - 间隔: {self.heartbeat_interval}秒, 连续成功: {consecutive_success}次"
                         )
-                        # 恢复后发送通知
-                        if self._alert_sent:
+                        # 恢复后发送通知（心跳成功一次即恢复）
+                        if self._alert_sent and consecutive_success >= 1:
+                            SYLogger.info(f"nacos:检测恢复状态 - _alert_sent={self._alert_sent}, consecutive_success={consecutive_success}")
                             self._alert_sent = False
+                            SYLogger.info(f"nacos:心跳已稳定恢复，发送恢复通知")
                             send_nacos_alert_sync(
                                 error_msg="心跳恢复正常",
                                 service_name=self.registration.service_name,
@@ -121,6 +132,7 @@ class NacosHeartbeatManager:
                                 is_recovered=True
                             )
                     else:
+                        consecutive_success = 0  # 失败时重置连续成功计数
                         consecutive_fail += 1
                         self._heartbeat_fail_count += 1
                         SYLogger.warning(
@@ -133,8 +145,13 @@ class NacosHeartbeatManager:
 
                         # 连续失败3次后发送告警（仅发送一次）
                         if consecutive_fail >= 3 and not self._alert_sent:
+                            SYLogger.info(f"nacos:准备发送断开告警 - consecutive_fail={consecutive_fail}, _alert_sent={self._alert_sent}")
                             self._alert_sent = True
                             self._disconnect_count += 1
+                            self._alert_fail_count = consecutive_fail  # 记录告警时的失败次数
+                            SYLogger.warning(
+                                f"nacos:心跳连续失败{consecutive_fail}次，发送告警通知，累计断开: {self._disconnect_count}次"
+                            )
                             send_nacos_alert_sync(
                                 error_msg=f"心跳连续失败{consecutive_fail}次",
                                 service_name=self.registration.service_name,
@@ -146,6 +163,7 @@ class NacosHeartbeatManager:
 
             except Exception as e:
                 consecutive_fail += 1
+                consecutive_success = 0  # 异常时重置连续成功计数
                 self._heartbeat_fail_count += 1
                 SYLogger.error(
                     f"nacos:心跳异常: {str(e)}, 连续失败: {consecutive_fail}次")
@@ -154,6 +172,10 @@ class NacosHeartbeatManager:
                 if consecutive_fail >= 3 and not self._alert_sent:
                     self._alert_sent = True
                     self._disconnect_count += 1
+                    self._alert_fail_count = consecutive_fail  # 记录告警时的失败次数
+                    SYLogger.warning(
+                        f"nacos:心跳异常连续失败{consecutive_fail}次，发送告警通知，累计断开: {self._disconnect_count}次"
+                    )
                     send_nacos_alert_sync(
                         error_msg=f"心跳异常: {str(e)}",
                         service_name=self.registration.service_name,
@@ -215,7 +237,8 @@ class NacosHeartbeatManager:
                 "version": self.registration.version} if self.registration.version else None
         )
 
-        if result and isinstance(result, dict) and result.get('lightBeatEnabled', False):
+        # 心跳成功：只要返回结果就认为成功（不依赖 lightBeatEnabled 字段）
+        if result:
             SYLogger.info(f"nacos:心跳发送成功，Nacos返回: {result}")
             return True
         else:

{sycommon_python_lib-0.2.0b21 → sycommon_python_lib-0.2.0b23}/src/sycommon/synacos/nacos_service_discovery.py

@@ -203,9 +203,17 @@ class NacosServiceDiscovery:
                                 )
                             registration.verify_registration()
                     else:
-                        # 服务正常，重置告警状态
+                        # 服务正常，重置告警状态并发送恢复通知
                         if self._service_alert_sent and current_registered:
                             self._service_alert_sent = False
+                            SYLogger.info(f"nacos:服务已恢复正常，发送恢复通知")
+                            send_nacos_service_alert_sync(
+                                error_msg="服务实例已恢复正常",
+                                service_name=registration.service_name,
+                                host=f"{registration.real_ip}:{registration.port}",
+                                is_service_down=False,
+                                disconnect_count=self._disconnect_count
+                            )
 
                 self.client_base._shutdown_event.wait(check_interval)
 

{sycommon_python_lib-0.2.0b21 → sycommon_python_lib-0.2.0b23}/src/sycommon_python_lib.egg-info/PKG-INFO

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