sycommon-python-lib 0.1.42__py3-none-any.whl → 0.1.44__py3-none-any.whl

sycommon/middleware/traceid.py

@@ -79,7 +79,7 @@ def setup_trace_id_handler(app):
 
             content_type = response.headers.get("Content-Type", "")
 
-            # 处理 SSE 响应 - 关键修复点
+            # 处理 SSE 响应
             if "text/event-stream" in content_type:
                 # 流式响应不能有Content-Length，移除它
                 if "Content-Length" in response.headers:

sycommon/rabbitmq/rabbitmq_client.py

@@ -85,6 +85,22 @@ class RabbitMQClient:
         # 线程安全锁
         self._consume_lock = asyncio.Lock()
         self._connect_lock = asyncio.Lock()
+        # 跟踪连接关闭回调（用于后续移除）
+        self._conn_close_callback: Optional[Callable] = None
+        # 控制重连频率的信号量（避免短时间内大量重连任务）
+        self._reconnect_semaphore = asyncio.Semaphore(1)
+        # 重连冷却时间（秒）
+        self._reconnect_cooldown = 3
+        # 固定重连间隔15秒（全局统一）
+        self._RECONNECT_INTERVAL = 15
+        # 重连任务锁（确保同一时间只有一个重连任务）
+        self._reconnect_task_lock = asyncio.Lock()
+        # 跟踪当前重连任务（避免重复创建）
+        self._current_reconnect_task: Optional[asyncio.Task] = None
+        # 连接失败计数器（用于告警）
+        self._reconnect_fail_count = 0
+        # 连接失败告警阈值
+        self._reconnect_alert_threshold = 5
 
     @property
     async def is_connected(self) -> bool:
@@ -104,14 +120,16 @@ class RabbitMQClient:
             return False
 
     async def connect(self) -> None:
-        """建立连接并初始化交换机/队列（支持重连）"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
         async with self._connect_lock:
-            # 释放旧的无效资源
+            # 释放旧资源（保留原有回调清理逻辑）
             if self._channel and self._channel_conn:
                 try:
+                    if self._conn_close_callback and self._channel_conn:
+                        self._channel_conn.close_callbacks.discard(
+                            self._conn_close_callback)
                     await self.connection_pool.release_channel(self._channel, self._channel_conn)
                 except Exception as e:
                     SYLogger.warning(f"释放旧通道失败: {str(e)}")
@@ -119,21 +137,28 @@ class RabbitMQClient:
             self._channel_conn = None
             self._exchange = None
             self._queue = None
+            self._conn_close_callback = None
 
             try:
-                # 1. 从连接池获取通道+连接
+                # 从连接池获取通道+连接（连接池已控制连接数）
                 self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
                 def on_conn_closed(conn: AbstractRobustConnection, exc: Optional[BaseException]):
-                    """连接关闭时触发的回调"""
-                    SYLogger.error(
+                    """连接关闭回调：触发固定间隔重连"""
+                    SYLogger.warning(
                         f"客户端连接关闭: {conn!r}，原因: {exc}", exc_info=exc)
+                    self._reconnect_fail_count += 1
+                    # 超过阈值告警
+                    if self._reconnect_fail_count >= self._reconnect_alert_threshold:
+                        SYLogger.error(
+                            f"连接失败次数已达阈值({self._reconnect_alert_threshold})，请检查MQ服务状态")
                     if not self._closed:
-                        asyncio.create_task(self.connect())
+                        asyncio.create_task(self._safe_reconnect())
 
-                # 给连接添加关闭回调
+                self._conn_close_callback = on_conn_closed
                 if self._channel_conn:
-                    self._channel_conn.close_callbacks.add(on_conn_closed)
+                    self._channel_conn.close_callbacks.add(
+                        self._conn_close_callback)
 
                 # 2. 设置预取计数（限流）
                 await self._channel.set_qos(prefetch_count=self.prefetch_count)
@@ -168,10 +193,15 @@ class RabbitMQClient:
                         f"（绑定交换机: {self.exchange_name}, routing_key: {self.routing_key}）"
                     )
 
+                # 重连成功，重置失败计数器
+                self._reconnect_fail_count = 0
                 SYLogger.info("客户端连接初始化完成")
             except Exception as e:
                 SYLogger.error(f"客户端连接失败: {str(e)}", exc_info=True)
                 # 清理异常状态
+                if self._conn_close_callback and self._channel_conn:
+                    self._channel_conn.close_callbacks.discard(
+                        self._conn_close_callback)
                 if self._channel and self._channel_conn:
                     try:
                         await self.connection_pool.release_channel(self._channel, self._channel_conn)
@@ -179,8 +209,40 @@ class RabbitMQClient:
                         pass
                 self._channel = None
                 self._channel_conn = None
+                # 触发重连（固定间隔）
+                if not self._closed:
+                    asyncio.create_task(self._safe_reconnect())
                 raise
 
+    async def _safe_reconnect(self):
+        """安全重连：固定15秒间隔，避免重复任务"""
+        # 检查是否已有重连任务在运行
+        if self._current_reconnect_task and not self._current_reconnect_task.done():
+            SYLogger.debug("已有重连任务在运行，跳过重复触发")
+            return
+
+        async with self._reconnect_task_lock:
+            if self._closed or await self.is_connected:
+                return
+
+            # 固定15秒重连间隔
+            SYLogger.info(f"将在15秒后尝试重连...")
+            await asyncio.sleep(self._RECONNECT_INTERVAL)
+
+            if self._closed or await self.is_connected:
+                return
+
+            try:
+                self._current_reconnect_task = asyncio.create_task(
+                    self.connect())
+                await self._current_reconnect_task
+            except Exception as e:
+                SYLogger.warning(f"重连失败: {str(e)}")
+                # 重连失败后，继续触发下一次重连（仍保持15秒间隔）
+                asyncio.create_task(self._safe_reconnect())
+            finally:
+                self._current_reconnect_task = None
+
     async def set_message_handler(
         self,
         handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]],
@@ -351,14 +413,18 @@ class RabbitMQClient:
         )
 
     async def close(self) -> None:
-        """关闭客户端（释放资源）"""
-        if self._closed:
-            SYLogger.warning("客户端已关闭，无需重复操作")
-            return
-
+        """关闭客户端（移除回调）"""
         self._closed = True
         SYLogger.info("开始关闭RabbitMQ客户端...")
 
+        # 停止重连任务
+        if self._current_reconnect_task and not self._current_reconnect_task.done():
+            self._current_reconnect_task.cancel()
+            try:
+                await self._current_reconnect_task
+            except asyncio.CancelledError:
+                SYLogger.debug("重连任务已取消")
+
         # 1. 停止消费
         await self.stop_consuming()
 
@@ -366,6 +432,10 @@ class RabbitMQClient:
         async with self._connect_lock:
             if self._channel and self._channel_conn:
                 try:
+                    # 移除连接关闭回调
+                    if self._conn_close_callback:
+                        self._channel_conn.close_callbacks.discard(
+                            self._conn_close_callback)
                     await self.connection_pool.release_channel(self._channel, self._channel_conn)
                     SYLogger.info("通道释放成功")
                 except Exception as e: