sycommon-python-lib 0.1.41__tar.gz → 0.1.45__tar.gz

{sycommon_python_lib-0.1.41 → sycommon_python_lib-0.1.45}/PKG-INFO

@@ -1,22 +1,22 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.41
+Version: 0.1.45
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: aio-pika>=9.5.7
-Requires-Dist: aiohttp>=3.13.1
+Requires-Dist: aio-pika>=9.5.8
+Requires-Dist: aiohttp>=3.13.2
 Requires-Dist: decorator>=5.2.1
-Requires-Dist: fastapi>=0.120.0
-Requires-Dist: kafka-python>=2.2.15
+Requires-Dist: fastapi>=0.121.2
+Requires-Dist: kafka-python>=2.2.16
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mysql-connector-python>=9.5.0
 Requires-Dist: nacos-sdk-python>=2.0.9
-Requires-Dist: pydantic>=2.12.3
+Requires-Dist: pydantic>=2.12.4
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: sqlalchemy>=2.0.44
-Requires-Dist: starlette>=0.48.0
+Requires-Dist: starlette>=0.49.3
 Requires-Dist: uuid>=1.30
 Requires-Dist: uvicorn>=0.38.0
 

{sycommon_python_lib-0.1.41 → sycommon_python_lib-0.1.45}/pyproject.toml

@@ -1,23 +1,23 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.41"
+version = "0.1.45"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "aio-pika>=9.5.7",
-    "aiohttp>=3.13.1",
+    "aio-pika>=9.5.8",
+    "aiohttp>=3.13.2",
     "decorator>=5.2.1",
-    "fastapi>=0.120.0",
-    "kafka-python>=2.2.15",
+    "fastapi>=0.121.2",
+    "kafka-python>=2.2.16",
     "loguru>=0.7.3",
     "mysql-connector-python>=9.5.0",
     "nacos-sdk-python>=2.0.9",
-    "pydantic>=2.12.3",
+    "pydantic>=2.12.4",
     "python-dotenv>=1.2.1",
     "pyyaml>=6.0.3",
     "sqlalchemy>=2.0.44",
-    "starlette>=0.48.0",
+    "starlette>=0.49.3",
     "uuid>=1.30",
     "uvicorn>=0.38.0",
 ]
@@ -25,5 +25,9 @@ dependencies = [
 [tool.setuptools]
 packages = {find = {where = ["src"]}}
 
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
 [project.scripts]
 sycommon = "command.cli:main"

{sycommon_python_lib-0.1.41 → sycommon_python_lib-0.1.45}/src/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_python_lib-0.1.41 → sycommon_python_lib-0.1.45}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -9,16 +9,13 @@ from aio_pika.abc import (
     AbstractQueue,
     AbstractIncomingMessage,
     ConsumerTag,
-    AbstractRobustConnection
+    AbstractRobustConnection,
 )
 from sycommon.rabbitmq.rabbitmq_pool import RabbitMQConnectionPool
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.models.mqmsg_model import MQMsgModel
 
 
-# 最大重试次数限制
-MAX_RETRY_COUNT = 3
-
 logger = SYLogger
 
 
@@ -27,10 +24,10 @@ class RabbitMQClient:
     RabbitMQ 客户端（支持消息发布、消费、自动重连、异常重试）
     核心特性：
     1. 基于连接池复用资源，性能优化
-    2. 连接/通道失效时自动重建，高可用
-    3. 消息发布支持重试，消费支持手动ACK/NACK
-    4. 兼容JSON/字符串/字典消息格式
-    5. 严格的协程调用规范，避免"未等待"警告
+    2. 连接/通道失效时自动重建，高可用（限制并发重连）
+    3. 消息发布支持重试+mandatory机制+超时控制，确保路由有效
+    4. 消费支持手动ACK/NACK
+    5. 兼容JSON/字符串/字典消息格式
     """
 
     def __init__(
@@ -45,7 +42,6 @@ class RabbitMQClient:
         auto_parse_json: bool = True,
         create_if_not_exists: bool = True,
         prefetch_count: int = 2,
-        # 兼容旧代码参数（无需使用）
         **kwargs,
     ):
         # 依赖注入：连接池（必须已初始化）
@@ -85,6 +81,20 @@ class RabbitMQClient:
         # 线程安全锁
         self._consume_lock = asyncio.Lock()
         self._connect_lock = asyncio.Lock()
+        # 跟踪连接关闭回调（用于后续移除）
+        self._conn_close_callback: Optional[Callable] = None
+        # 控制重连频率的信号量（限制并发重连数，默认1个）
+        self._reconnect_semaphore = asyncio.Semaphore(1)
+        # 固定重连间隔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 +114,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,16 +131,38 @@ class RabbitMQClient:
             self._channel_conn = None
             self._exchange = None
             self._queue = None
+            self._conn_close_callback = None
 
             try:
-                # 1. 从连接池获取通道+连接
+                # 从连接池获取通道+连接（连接池返回的是 RobustChannel）
                 self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
+                def on_conn_closed(conn: AbstractRobustConnection, exc: Optional[BaseException]):
+                    """连接关闭回调：触发固定间隔重连"""
+                    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._safe_reconnect())
+
+                self._conn_close_callback = on_conn_closed
+                if self._channel_conn:
+                    self._channel_conn.close_callbacks.add(
+                        self._conn_close_callback)
+
                 # 2. 设置预取计数（限流）
                 await self._channel.set_qos(prefetch_count=self.prefetch_count)
                 SYLogger.debug(f"设置预取计数: {self.prefetch_count}")
 
-                # 3. 声明交换机
+                # 3. 低版本 RobustChannel 说明：默认启用异步发布确认，无显式确认方法
+                SYLogger.debug(
+                    "基于 RobustChannel 异步发布确认（低版本 aio-pika 不支持显式确认方法）")
+
+                # 4. 声明交换机
                 self._exchange = await self._channel.declare_exchange(
                     name=self.exchange_name,
                     type=self.exchange_type,
@@ -139,7 +173,7 @@ class RabbitMQClient:
                 SYLogger.info(
                     f"交换机初始化成功: {self.exchange_name}（类型: {self.exchange_type.value}）")
 
-                # 4. 声明队列（如果配置了队列名）
+                # 5. 声明队列（如果配置了队列名）
                 if self.queue_name:
                     self._queue = await self._channel.declare_queue(
                         name=self.queue_name,
@@ -157,10 +191,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)
@@ -168,8 +207,45 @@ 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秒间隔，避免短时间大量重连"""
+        # 1. 信号量控制：限制同时进行的重连任务数（默认1个）
+        async with self._reconnect_semaphore:
+            # 2. 检查是否已有重连任务在运行（双重保障）
+            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:
+                    SYLogger.debug("客户端已关闭或已连接，取消重连")
+                    return
+
+                # 3. 固定15秒重连间隔（避免频繁重试）
+                SYLogger.info(f"将在15秒后尝试重连...")
+                await asyncio.sleep(self._RECONNECT_INTERVAL)
+
+                if self._closed or await self.is_connected:
+                    SYLogger.debug("重连等待期间客户端状态变化，取消重连")
+                    return
+
+                try:
+                    # 4. 执行重连
+                    SYLogger.info("开始重连RabbitMQ客户端...")
+                    self._current_reconnect_task = asyncio.create_task(
+                        self.connect())
+                    await self._current_reconnect_task
+                except Exception as e:
+                    SYLogger.warning(f"重连失败: {str(e)}")
+                    # 重连失败后，不主动触发下一次（等待连接关闭回调再次触发，避免死循环）
+                finally:
+                    self._current_reconnect_task = None
+
     async def set_message_handler(
         self,
         handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]],
@@ -242,7 +318,7 @@ class RabbitMQClient:
                     # 检查连接状态，失效则触发重连
                     if not await self.is_connected:
                         SYLogger.warning("连接已失效，触发客户端重连")
-                        asyncio.create_task(self.connect())
+                        asyncio.create_task(self._safe_reconnect())
 
             # 3. 启动消费
             self._consumer_tag = await self._queue.consume(consume_callback)
@@ -272,7 +348,7 @@ class RabbitMQClient:
         retry_count: int = 3,
     ) -> None:
         """
-        发布消息（支持自动重试、JSON序列化）
+        发布消息（支持自动重试、mandatory路由校验、5秒超时控制）
         :param message_body: 消息体（字符串/字典/MQMsgModel）
         :param headers: 消息头（可选）
         :param content_type: 内容类型（默认application/json）
@@ -314,40 +390,64 @@ class RabbitMQClient:
                     SYLogger.warning(f"发布消息前连接失效，触发重连（retry: {retry}）")
                     await self.connect()
 
-                # 发布消息
-                await self._exchange.publish(
+                # 核心：发布消息（添加 mandatory=True 和 timeout=5.0）
+                publish_result = await self._exchange.publish(
                     message=message,
                     routing_key=self.routing_key or self.queue_name or "#",
+                    mandatory=True,  # 强制路由到至少一个队列，否则返回None
+                    timeout=5.0      # 5秒超时控制，避免无限阻塞
                 )
+
+                # 处理 mandatory=True 结果：未路由到队列返回 None，直接抛出异常
+                if publish_result is None:
+                    raise RuntimeError(
+                        f"消息未找到匹配的队列（routing_key: {self.routing_key}），mandatory=True 触发失败"
+                    )
+
+                # 低版本 RobustChannel 异步确认，无需显式等待，仅日志说明
                 SYLogger.info(
                     f"消息发布成功（retry: {retry}），routing_key: {self.routing_key}，"
-                    f"delivery_mode: {delivery_mode.value}"
+                    f"delivery_mode: {delivery_mode.value}，mandatory: True，timeout: 5.0s"
                 )
                 return
+            except asyncio.TimeoutError:
+                SYLogger.error(
+                    f"消息发布超时（retry: {retry}/{retry_count-1}），超时时间: 5.0s"
+                )
+            except RuntimeError as e:
+                # 捕获 mandatory 未路由等业务异常
+                SYLogger.error(
+                    f"消息发布业务失败（retry: {retry}/{retry_count-1}）: {str(e)}"
+                )
             except Exception as e:
                 SYLogger.error(
                     f"消息发布失败（retry: {retry}/{retry_count-1}）: {str(e)}",
                     exc_info=True
                 )
-                # 清理失效状态，下次重试时重连
+                # 清理失效状态，下次重试重连
                 self._exchange = None
-                # 重试间隔（指数退避）
-                await asyncio.sleep(0.5 * (2 ** retry))
+            # 指数退避重试间隔（0.5s, 1s, 2s...）
+            await asyncio.sleep(0.5 * (2 ** retry))
 
-        # 所有重试失败，抛出异常
+        # 所有重试失败，抛出最终异常
         raise RuntimeError(
-            f"消息发布失败（已重试{retry_count}次），routing_key: {self.routing_key}"
+            f"消息发布失败（已重试{retry_count}次），routing_key: {self.routing_key}，"
+            f"mandatory: True，timeout: 5.0s"
         )
 
     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()
 
@@ -355,6 +455,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: