sycommon-python-lib 0.1.56b4__py3-none-any.whl → 0.1.56b6__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_client.py

@@ -145,10 +145,15 @@ class RabbitMQClient:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
         async with self._connect_lock:
-            # 释放旧资源（回调+通道，单通道无需归还，仅清理状态）
-            if self._conn_close_callback and self._channel_conn:
-                self._channel_conn.close_callbacks.discard(
-                    self._conn_close_callback)
+            # 1. 清理旧连接回调（防止内存泄漏）
+            if self._channel_conn and self._conn_close_callback:
+                try:
+                    self._channel_conn.close_callbacks.discard(
+                        self._conn_close_callback)
+                except Exception:
+                    pass
+
+            # 2. 清理状态
             self._channel = None
             self._channel_conn = None
             self._exchange = None
@@ -156,18 +161,14 @@ class RabbitMQClient:
             self._conn_close_callback = None
 
             try:
-                # 从单通道池获取通道+连接（连接池自动确保通道有效）
+                # 3. 获取新通道
                 self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
+                # 4. 设置新连接回调（使用 weakref）
                 def on_conn_closed(conn: AbstractRobustConnection, exc: Optional[BaseException]):
-                    """连接关闭回调：触发固定间隔重连"""
-                    logger.warning(
-                        f"客户端连接关闭: {conn!r}，原因: {exc}", exc_info=exc)
-                    self._reconnect_fail_count += 1
-                    # 超过阈值告警
-                    if self._reconnect_fail_count >= self._reconnect_alert_threshold:
-                        logger.error(
-                            f"连接失败次数已达阈值({self._reconnect_alert_threshold})，请检查MQ服务状态")
+                    # 注意：这里需要访问外部的 self，使用闭包或 weakref
+                    # 简单起见，这里用闭包，但务必在 self.close 或 self.connect 时清理回调
+                    logger.warning(f"检测到连接关闭: {exc}")
                     if not self._closed:
                         asyncio.create_task(self._safe_reconnect())
 
@@ -176,20 +177,26 @@ class RabbitMQClient:
                     self._channel_conn.close_callbacks.add(
                         self._conn_close_callback)
 
-                # 重建交换机/队列资源
+                # 5. 重建资源
                 await self._rebuild_resources()
 
-                # 重连成功，重置失败计数器
+                # 重置计数
                 self._reconnect_fail_count = 0
                 logger.info("客户端连接初始化完成")
             except Exception as e:
                 logger.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_conn and self._conn_close_callback:
+                    try:
+                        self._channel_conn.close_callbacks.discard(
+                            self._conn_close_callback)
+                    except Exception:
+                        pass
+                # 清空状态
                 self._channel = None
                 self._channel_conn = None
+                self._conn_close_callback = None
+
                 # 触发重连
                 if not self._closed:
                     asyncio.create_task(self._safe_reconnect())
@@ -238,7 +245,7 @@ class RabbitMQClient:
             logger.info("消息处理器设置成功")
 
     async def start_consuming(self) -> Optional[ConsumerTag]:
-        """启动消息消费（支持自动重连）"""
+        """启动消息消费（支持自动重连 + Header 重试计数限制）"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法启动消费")
 
@@ -251,10 +258,11 @@ class RabbitMQClient:
             if not self._queue:
                 raise RuntimeError("未配置队列名或队列未创建，无法启动消费")
 
-            # 2. 定义消费回调（包含异常处理和重连逻辑）
+            # 2. 定义消费回调
             async def consume_callback(message: AbstractIncomingMessage):
                 try:
                     # 解析消息体
+                    msg_obj: MQMsgModel
                     if self.auto_parse_json:
                         try:
                             body_dict = json.loads(
@@ -263,19 +271,26 @@ class RabbitMQClient:
                         except json.JSONDecodeError as e:
                             logger.error(
                                 f"JSON消息解析失败: {str(e)}，消息体: {message.body[:100]}...")
-                            await message.nack(requeue=False)  # 解析失败，不重入队
+                            # 解析失败通常无法重试，直接丢弃
+                            await message.nack(requeue=False)
                             return
                     else:
                         msg_obj = MQMsgModel(
                             body=message.body.decode("utf-8"),
                             routing_key=message.routing_key,
                             delivery_tag=message.delivery_tag,
+                            traceId=message.headers.get("trace-id", None),
+                            headers=message.headers
                         )
 
+                    # 统一追踪ID
+                    SYLogger.set_trace_id(
+                        message.headers.get("trace-id", None))
+
                     # 调用消息处理器
                     await self._message_handler(msg_obj, message)
 
-                    # 手动ACK
+                    # 处理成功，手动ACK
                     await message.ack()
                     logger.debug(
                         f"消息处理成功，delivery_tag: {message.delivery_tag}")
@@ -285,19 +300,61 @@ class RabbitMQClient:
                         f"消息处理失败，delivery_tag: {message.delivery_tag}",
                         exc_info=True
                     )
-                    # 处理失败逻辑：首次失败重入队，再次失败丢弃
-                    if message.redelivered:
+
+                    # 1. 获取当前重试次数，默认为 0
+                    current_retry_count = 0
+                    if message.headers:
+                        current_retry_count = int(
+                            message.headers.get("x-retry-count", 0))
+
+                    # 2. 检查是否超过最大重试次数 (3次)
+                    MAX_RETRY = 3
+                    if current_retry_count >= MAX_RETRY:
                         logger.warning(
-                            f"消息已重入队过，本次拒绝入队: {message.delivery_tag}")
+                            f"消息重试次数已达上限({MAX_RETRY})，丢弃消息。"
+                            f"delivery_tag: {message.delivery_tag}, routing_key: {message.routing_key}"
+                        )
+                        # 丢弃消息（不重新入队）
                         await message.reject(requeue=False)
-                    else:
-                        logger.warning(f"消息重入队: {message.delivery_tag}")
-                        await message.nack(requeue=True)
+                        return
 
-                    # 连接失效则触发重连
-                    if not await self.is_connected:
-                        logger.warning("连接已失效，触发客户端重连")
-                        asyncio.create_task(self._safe_reconnect())
+                    # 3. 次数未满，准备重入队
+                    # 注意：AbstractIncomingMessage.headers 是只读的 (frozendict)，
+                    # 不能直接 message.headers["x-retry-count"] = ...
+                    # 必须重新构造 headers 字典。
+                    new_headers = dict(
+                        message.headers) if message.headers else {}
+                    new_headers["x-retry-count"] = current_retry_count + 1
+
+                    logger.warning(
+                        f"消息处理失败，准备第 {current_retry_count + 1} 次重入队。"
+                        f"delivery_tag: {message.delivery_tag}"
+                    )
+
+                    try:
+                        new_msg = Message(
+                            body=message.body,
+                            headers=new_headers,
+                            content_type=message.content_type,
+                            delivery_mode=message.delivery_mode
+                        )
+
+                        # 发布到原 Exchange 和 RoutingKey
+                        # 注意：这里可能会抛出异常，如果抛异常，消息可能会丢失（因为已经 Nack 掉了）
+                        await self._exchange.publish(
+                            new_msg,
+                            routing_key=message.routing_key
+                        )
+
+                        # 发布成功后，Ack 掉旧消息
+                        await message.ack()
+                        logger.info(
+                            f"消息已重新发布 (重试次数: {new_headers['x-retry-count']})")
+
+                    except Exception as publish_err:
+                        logger.error(f"重新发布消息失败(消息丢失): {publish_err}")
+                        # 重新发布失败，只能丢弃或者 Nack(False)
+                        await message.reject(requeue=False)
 
             # 3. 启动消费（单通道消费，避免阻塞发布需确保业务回调非阻塞）
             self._consumer_tag = await self._queue.consume(consume_callback)

sycommon/rabbitmq/rabbitmq_pool.py

@@ -5,16 +5,26 @@ from aio_pika import connect_robust, RobustChannel, Message
 from aio_pika.abc import (
     AbstractRobustConnection, AbstractQueue, AbstractExchange, AbstractMessage
 )
-from aio_pika.exceptions import ChannelClosed
-import aiormq.exceptions
-
 from sycommon.logging.kafka_log import SYLogger
 
 logger = SYLogger
 
 
+class AsyncProperty:
+    """实现 await obj.attr 的支持"""
+
+    def __init__(self, method):
+        self.method = method
+
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            return self
+        # 关键：当访问 obj.attr 时，直接返回协程对象，而不是方法本身
+        return self.method(obj)
+
+
 class RabbitMQConnectionPool:
-    """单连接单通道RabbitMQ客户端（核心特性：依赖connect_robust原生自动重连/恢复 + 仅关闭时释放资源）"""
+    """单连接单通道RabbitMQ客户端 (增强版日志)"""
 
     def __init__(
         self,
@@ -29,7 +39,6 @@ class RabbitMQConnectionPool:
         reconnect_interval: int = 5,
         prefetch_count: int = 2,
     ):
-        # 基础配置校验与初始化
         self.hosts = [host.strip() for host in hosts if host.strip()]
         if not self.hosts:
             raise ValueError("至少需要提供一个RabbitMQ主机地址")
@@ -44,295 +53,318 @@ class RabbitMQConnectionPool:
         self.reconnect_interval = reconnect_interval
         self.prefetch_count = prefetch_count
 
-        # 初始化时随机选择一个主机地址（固定使用，依赖原生重连）
         self._current_host: str = random.choice(self.hosts)
-        logger.info(
-            f"随机选择RabbitMQ主机: {self._current_host}（依赖connect_robust原生自动重连/恢复）")
+        logger.info(f"[INIT] 随机选择RabbitMQ主机: {self._current_host}")
 
-        # 核心资源（单连接+单通道，基于原生自动重连）
-        self._connection: Optional[AbstractRobustConnection] = None  # 原生自动重连连接
-        self._channel: Optional[RobustChannel] = None  # 单通道（原生自动恢复）
-        # 消费者通道跟踪（独立于主通道）
-        self._consumer_channels: Dict[str,
-                                      Tuple[RobustChannel, Callable, bool, dict]] = {}
+        # 核心资源
+        self._connection: Optional[AbstractRobustConnection] = None
+        self._channel: Optional[RobustChannel] = None
+        self._consumer_channels: Dict[str, RobustChannel] = {}
 
-        # 状态控制（并发安全+生命周期管理）
+        # 状态控制
         self._lock = asyncio.Lock()
         self._initialized = False
         self._is_shutdown = False
 
-    async def _is_connection_valid(self) -> bool:
-        """原子化检查连接有效性（所有状态判断均加锁，确保原子性）"""
-        async with self._lock:
-            # 优先级：先判断是否关闭，再判断是否初始化，最后判断连接状态
-            return not self._is_shutdown and self._initialized and self._connection is not None and not self._connection.is_closed
-
-    @property
+    @AsyncProperty
     async def is_alive(self) -> bool:
         """对外暴露的连接存活状态（原子化判断）"""
         async with self._lock:
             if self._is_shutdown:
                 return False
-            # 存活条件：未关闭 + 已初始化 + 连接有效 + 主通道有效
-            return self._initialized and self._connection is not None and not self._connection.is_closed and self._channel is not None and not self._channel.is_closed
 
-    async def _create_connection(self) -> AbstractRobustConnection:
-        """创建原生自动重连连接（仅创建一次，内部自动重试）"""
-        async with self._lock:
-            if self._is_shutdown:
-                raise RuntimeError("客户端已关闭，无法创建连接")
+            if not self._initialized:
+                return False
 
-        conn_url = f"amqp://{self.username}:{self.password}@{self._current_host}:{self.port}/{self.virtualhost}?name={self.app_name}&heartbeat={self.heartbeat}&reconnect_interval={self.reconnect_interval}&fail_fast=1"
-        logger.info(f"尝试创建原生自动重连连接: {self._current_host}:{self.port}")
+            if self._connection is None or self._connection.is_closed:
+                return False
+
+            # 可选：检查主通道是否存活
+            if self._channel is None or self._channel.is_closed:
+                # 如果你认为通道断了连接也算死，就保留这行；否则删除
+                return False
 
+            return True
+
+    async def _create_connection_impl(self) -> AbstractRobustConnection:
+        """
+        连接创建入口
+        """
+        conn_url = (
+            f"amqp://{self.username}:{self.password}@{self._current_host}:{self.port}/"
+            f"{self.virtualhost}?name={self.app_name}&heartbeat={self.heartbeat}"
+            f"&reconnect_interval={self.reconnect_interval}&fail_fast=1"
+        )
+        logger.info(
+            f"🔌 [CONNECT_START] 尝试创建连接 -> {self._current_host}:{self.port}")
         try:
-            conn = await connect_robust(
-                conn_url,
-                timeout=self.connection_timeout,
-            )
-            logger.info(f"连接创建成功: {self._current_host}:{self.port}（原生自动重连已启用）")
+            conn = await connect_robust(conn_url, timeout=self.connection_timeout)
+            # 注意：connect_robust 返回时，底层 TCP 可能还在握手，但对象已创建
+            logger.info(f"✅ [CONNECT_OK] 连接对象创建成功: {id(conn)}")
             return conn
         except Exception as e:
-            logger.error(f"连接创建失败: {str(e)}", exc_info=True)
-            raise ConnectionError(
-                f"无法连接RabbitMQ主机 {self._current_host}:{self.port}") from e
-
-    async def _init_single_channel(self):
-        """初始化单通道（通道自带原生自动恢复）"""
-        async with self._lock:
-            # 先判断是否关闭（优先级最高）
-            if self._is_shutdown:
-                raise RuntimeError("客户端已关闭，无法初始化通道")
-            # 再判断连接是否有效
-            if not self._connection or self._connection.is_closed:
-                raise RuntimeError("无有效连接，无法初始化通道")
-
-            # 清理旧通道（如果存在）
-            if self._channel and not self._channel.is_closed:
-                await self._channel.close()
+            logger.error(f"❌ [CONNECT_FAIL] 连接创建失败: {str(e)}")
+            raise ConnectionError(f"无法连接RabbitMQ {self._current_host}") from e
 
-            # 创建单通道并设置QOS
-            try:
-                self._channel = await self._connection.channel()
-                await self._channel.set_qos(prefetch_count=self.prefetch_count)
-                logger.info(f"单通道初始化完成（带原生自动恢复）")
-            except Exception as e:
-                logger.error(f"创建单通道失败: {str(e)}", exc_info=True)
-                raise
+    async def _create_channel_impl(self, connection: AbstractRobustConnection) -> RobustChannel:
+        """创建通道"""
+        try:
+            channel = await connection.channel()
+            await channel.set_qos(prefetch_count=self.prefetch_count)
+            logger.debug(f"✅ [CHANNEL_OK] 通道创建成功: {id(channel)}")
+            return channel
+        except Exception as e:
+            logger.error(f"❌ [CHANNEL_FAIL] 通道创建失败: {str(e)}")
+            raise
 
-    async def _check_and_recover_channel(self) -> RobustChannel:
-        """检查并恢复通道（确保通道有效，所有状态判断加锁）"""
+    async def _ensure_main_channel(self) -> RobustChannel:
+        """确保主通道有效 (原子操作 + 自动轮询重试 + 失败清理)"""
         async with self._lock:
-            # 1. 先判断是否关闭（优先级最高）
             if self._is_shutdown:
-                raise RuntimeError("客户端已关闭，无法获取通道")
-            # 2. 检查连接状态
-            if not self._connection or self._connection.is_closed:
-                raise RuntimeError("连接已关闭（等待原生重连）")
-            # 3. 通道失效时重新创建
-            if not self._channel or self._channel.is_closed:
-                logger.warning("通道失效，重新创建（依赖原生自动恢复）")
-                await self._init_single_channel()
+                raise RuntimeError("客户端已关闭")
+
+            # 如果连接对象不存在或已关闭，进入重连流程
+            if self._connection is None or self._connection.is_closed:
+                retry_hosts = self.hosts.copy()  # 复制一份列表用于重试
+                last_error = None
+                temp_conn = None  # 临时变量，用于引用本次尝试创建的连接
+
+                # 轮询尝试列表中的每一个 Host
+                while retry_hosts:
+                    host = random.choice(retry_hosts)
+                    retry_hosts.remove(host)  # 从待尝试列表中移除
+
+                    logger.info(f"⚠️ [RECONNECT] 尝试连接节点: {host}")
+                    self._current_host = host
+                    temp_conn = None  # 重置临时引用
+
+                    try:
+                        conn_url = (
+                            f"amqp://{self.username}:{self.password}@{host}:{self.port}/"
+                            f"{self.virtualhost}?name={self.app_name}&heartbeat={self.heartbeat}"
+                            f"&reconnect_interval={self.reconnect_interval}&fail_fast=1"
+                        )
+
+                        # 尝试连接
+                        temp_conn = await connect_robust(conn_url, timeout=self.connection_timeout)
+
+                        # --- 关键点：连接成功 ---
+                        self._connection = temp_conn
+                        temp_conn = None  # 清空临时引用，因为所有权已经移交给 self._connection
+
+                        logger.info(f"🔗 [RECONNECT_OK] 成功连接到节点: {host}")
+                        last_error = None
+                        break  # 成功，跳出循环
+
+                    except Exception as e:
+                        logger.warning(
+                            f"❌ [RECONNECT_FAIL] 节点 {host} 不可用: {str(e)}")
+
+                        # 【核心修复】清理失败的连接对象
+                        if temp_conn is not None:
+                            try:
+                                logger.debug(
+                                    f"🧹 [CLEANUP] 正在关闭失败的连接对象: {id(temp_conn)}")
+                                # 即使连接对象处于异常状态，close() 通常也是安全的
+                                await temp_conn.close()
+                                logger.debug(f"✅ [CLEANUP] 失败连接已关闭")
+                            except Exception as close_err:
+                                logger.warning(
+                                    f"⚠️ [CLEANUP_ERR] 关闭失败连接时出错: {str(close_err)}")
+
+                        last_error = e
+                        asyncio.sleep(self.reconnect_interval)
+                        continue  # 继续试下一个
+
+                # 如果所有节点都试完了还是失败
+                if last_error:
+                    logger.error("💥 [RECONNECT_FATAL] 所有 RabbitMQ 节点均不可用")
+                    raise ConnectionError("所有 RabbitMQ 节点连接失败") from last_error
+
+            # 2. 确保主通道存在
+            if self._channel is None or self._channel.is_closed:
+                logger.info("⚠️ [RECOVER_CHANNEL] 检测到主通道不存在或已关闭，开始恢复...")
+                self._channel = await self._create_channel_impl(self._connection)
 
             return self._channel
 
     async def init_pools(self):
-        """初始化客户端（仅执行一次）"""
+        """
+        初始化入口与异常处理 (修复泄漏的关键)
+        """
         async with self._lock:
-            # 原子化判断：是否已关闭/已初始化
             if self._is_shutdown:
-                raise RuntimeError("客户端已关闭，无法初始化")
+                raise RuntimeError("客户端已关闭")
             if self._initialized:
-                logger.warning("客户端已初始化，无需重复调用")
                 return
 
+        conn_created_in_this_try = None
         try:
-            # 1. 创建原生自动重连连接
-            self._connection = await self._create_connection()
+            # 步骤 A: 创建连接 (在锁外进行，避免阻塞其他操作)
+            conn = await self._create_connection_impl()
+            conn_created_in_this_try = conn  # 记录本次创建的对象，用于失败回滚
 
-            # 2. 初始化单通道
-            await self._init_single_channel()
-
-            # 3. 标记为已初始化（加锁保护）
+            # 步骤 B: 更新状态和初始化通道 (在锁内进行，保证原子性)
             async with self._lock:
+                if self._is_shutdown:
+                    # 如果在创建连接期间，外部调用了 close，则必须立即清理刚创建的连接
+                    logger.warning("⚠️ [ABORT] 检测到关闭信号，放弃初始化并清理资源")
+                    raise RuntimeError("客户端已关闭")
+
+                self._connection = conn
+                self._channel = await self._create_channel_impl(conn)
                 self._initialized = True
+                logger.info(
+                    f"🚀 [INIT_SUCCESS] 客户端初始化完成. ConnID: {id(self._connection)}")
 
-            logger.info("RabbitMQ单通道客户端初始化完成（原生自动重连/恢复已启用）")
         except Exception as e:
-            logger.error(f"初始化失败: {str(e)}", exc_info=True)
-            await self.close()  # 初始化失败直接关闭
+            logger.error(f"💥 [INIT_ERROR] 初始化流程异常: {str(e)}", exc_info=True)
+            # 如果步骤A成功但步骤B失败（例如通道创建失败），或者步骤B中出错，
+            # 必须显式关闭在步骤A中创建的连接，否则它会变成“游离连接”。
+            if conn_created_in_this_try:
+                logger.warning(
+                    f"🧹 [LEAK_PREVENTION] 检测到初始化失败，正在显式关闭刚创建的连接: {id(conn_created_in_this_try)}")
+                try:
+                    await conn_created_in_this_try.close()
+                    logger.info(
+                        f"✅ [CLOSE_OK] 泄漏连接已关闭: {id(conn_created_in_this_try)}")
+                except Exception as close_err:
+                    logger.error(f"❌ [CLOSE_ERR] 关闭泄漏连接时出错: {str(close_err)}")
+
+            # 如果是因为中途关闭导致的错误，不需要再次调用全局 close，否则调用
+            if not self._is_shutdown:
+                await self.close()
             raise
 
     async def acquire_channel(self) -> Tuple[RobustChannel, AbstractRobustConnection]:
-        """获取单通道（返回 (通道, 连接) 元组，保持API兼容）"""
-        async with self._lock:
-            # 原子化状态校验
-            if self._is_shutdown:
-                raise RuntimeError("客户端已关闭，无法获取通道")
-            if not self._initialized:
-                raise RuntimeError("客户端未初始化，请先调用init_pools()")
-
-        # 检查并恢复通道
-        channel = await self._check_and_recover_channel()
-        return channel, self._connection  # 单通道无需管理"使用中/空闲"状态
-
-    async def declare_queue(self, queue_name: str, **kwargs) -> AbstractQueue:
-        """声明队列（使用单通道）"""
-        channel, _ = await self.acquire_channel()
-        return await channel.declare_queue(queue_name, **kwargs)
-
-    async def declare_exchange(self, exchange_name: str, exchange_type: str = "direct", **kwargs) -> AbstractExchange:
-        """声明交换机（使用单通道）"""
-        channel, _ = await self.acquire_channel()
-        return await channel.declare_exchange(exchange_name, exchange_type, **kwargs)
+        """获取主通道"""
+        if not self._initialized and not self._is_shutdown:
+            await self.init_pools()
+        return await self._ensure_main_channel(), self._connection
 
     async def publish_message(self, routing_key: str, message_body: bytes, exchange_name: str = "", **kwargs):
-        """发布消息（依赖原生自动重连/恢复）"""
+        """发布消息"""
         channel, _ = await self.acquire_channel()
         try:
             exchange = channel.default_exchange if not exchange_name else await channel.get_exchange(exchange_name)
             message = Message(body=message_body, **kwargs)
             await exchange.publish(message, routing_key=routing_key)
-            logger.debug(
-                f"消息发布成功 - 交换机: {exchange.name}, 路由键: {routing_key}"
-            )
+            logger.debug(f"📤 [PUBLISH] 消息发布成功 - RK: {routing_key}")
         except Exception as e:
-            logger.error(f"发布消息失败: {str(e)}", exc_info=True)
-            raise  # 原生会自动重连，无需手动处理
+            logger.error(f"❌ [PUBLISH_FAIL] 发布失败: {str(e)}")
+            raise
 
     async def consume_queue(self, queue_name: str, callback: Callable[[AbstractMessage], asyncio.Future], auto_ack: bool = False, **kwargs):
-        """消费队列（独立通道，带原生自动恢复）"""
+        """消费队列"""
+        if not self._initialized:
+            await self.init_pools()
+
         async with self._lock:
-            # 原子化状态校验
             if self._is_shutdown:
-                raise RuntimeError("客户端已关闭，无法启动消费")
-            if not self._initialized:
-                raise RuntimeError("客户端未初始化，请先调用init_pools()")
+                raise RuntimeError("客户端已关闭")
             if queue_name in self._consumer_channels:
-                logger.warning(f"队列 {queue_name} 已在消费中，无需重复启动")
+                logger.warning(f"⚠️ [CONSUMER_EXISTS] 队列 {queue_name} 已在消费中")
                 return
+            if not self._connection or self._connection.is_closed:
+                raise RuntimeError("连接不可用，无法启动消费")
 
-        # 先声明队列（确保队列存在）
         await self.declare_queue(queue_name, **kwargs)
 
-        # 创建独立的消费者通道（不使用主单通道，避免消费阻塞发布）
-        async with self._lock:
-            if self._is_shutdown:  # 二次校验：防止创建通道前客户端被关闭
-                raise RuntimeError("客户端已关闭，无法创建消费者通道")
-            if not self._connection or self._connection.is_closed:
-                raise RuntimeError("无有效连接，无法创建消费者通道")
-            channel = await self._connection.channel()
-            await channel.set_qos(prefetch_count=self.prefetch_count)
+        try:
+            # 获取原始连接对象创建新通道
+            conn = self._connection
+            consumer_channel = await conn.channel()
+            await consumer_channel.set_qos(prefetch_count=self.prefetch_count)
+            logger.info(
+                f"✅ [CONSUMER_CHANNEL_OK] 消费者通道创建: {id(consumer_channel)}")
 
-            # 注册消费者通道
-            self._consumer_channels[queue_name] = (
-                channel, callback, auto_ack, kwargs)
+            async with self._lock:
+                if self._is_shutdown:
+                    await consumer_channel.close()
+                    return
+                self._consumer_channels[queue_name] = consumer_channel
 
-        async def consume_callback_wrapper(message: AbstractMessage):
-            """消费回调包装（处理通道失效，依赖原生恢复）"""
-            try:
-                async with self._lock:
-                    # 原子化校验状态：客户端是否关闭 + 通道是否有效 + 连接是否有效
-                    if self._is_shutdown:
-                        logger.warning(f"客户端已关闭，拒绝处理消息（队列: {queue_name}）")
-                        if not auto_ack:
-                            await message.nack(requeue=True)
-                        return
-                    channel_valid = not channel.is_closed
-                    conn_valid = self._connection and not self._connection.is_closed
-
-                if not channel_valid or not conn_valid:
-                    logger.warning(f"消费者通道 {queue_name} 失效（等待原生自动恢复）")
+            async def consume_callback_wrapper(message: AbstractMessage):
+                try:
+                    await callback(message)
+                    if not auto_ack:
+                        await message.ack()
+                except Exception as e:
+                    logger.error(
+                        f"❌ [CALLBACK_ERR] 消费回调异常 {queue_name}: {str(e)}")
                     if not auto_ack:
                         await message.nack(requeue=True)
-                    return
-
-                # 执行业务回调
-                await callback(message)
-                if not auto_ack:
-                    await message.ack()
-            except ChannelClosed as e:
-                logger.error(f"消费者通道 {queue_name} 关闭: {str(e)}", exc_info=True)
-                if not auto_ack:
-                    await message.nack(requeue=True)
-            except aiormq.exceptions.ChannelInvalidStateError as e:
-                logger.error(
-                    f"消费者通道 {queue_name} 状态异常: {str(e)}", exc_info=True)
-                if not auto_ack:
-                    await message.nack(requeue=True)
-            except Exception as e:
-                logger.error(
-                    f"消费消息失败（队列: {queue_name}）: {str(e)}", exc_info=True)
-                if not auto_ack:
-                    await message.nack(requeue=True)
 
-        logger.info(f"开始消费队列: {queue_name}（通道带原生自动恢复）")
-
-        try:
-            await channel.basic_consume(
-                queue_name,
-                consumer_callback=consume_callback_wrapper,
-                auto_ack=auto_ack,
-                **kwargs
+            await consumer_channel.basic_consume(
+                queue_name, consumer_callback=consume_callback_wrapper, auto_ack=auto_ack, **kwargs
             )
+            logger.info(f"🎧 [CONSUME_START] 开始消费队列: {queue_name}")
+
         except Exception as e:
-            logger.error(f"启动消费失败（队列: {queue_name}）: {str(e)}", exc_info=True)
-            # 清理异常资源
-            try:
-                async with self._lock:
-                    if not channel.is_closed:
-                        await channel.close()
-                    # 移除无效的消费者通道注册
-                    if queue_name in self._consumer_channels:
-                        del self._consumer_channels[queue_name]
-            except Exception as close_e:
-                logger.warning(f"关闭消费者通道失败: {str(close_e)}")
+            logger.error(f"💥 [CONSUME_ERR] 启动消费失败 {queue_name}: {str(e)}")
+            async with self._lock:
+                if queue_name in self._consumer_channels:
+                    del self._consumer_channels[queue_name]
             raise
 
     async def close(self):
-        """关闭客户端（释放所有资源，原子化状态管理）"""
+        """
+        资源销毁入口
+        """
         async with self._lock:
             if self._is_shutdown:
-                logger.warning("客户端已关闭，无需重复操作")
                 return
-            # 先标记为关闭，阻止后续所有操作（原子化修改）
             self._is_shutdown = True
             self._initialized = False
+            # 记录即将关闭的连接ID
+            conn_to_close_id = id(
+                self._connection) if self._connection else None
 
-        logger.info("开始关闭RabbitMQ单通道客户端（释放所有资源）...")
+        logger.info(f"🛑 [CLOSE_START] 开始关闭客户端... (准备关闭连接: {conn_to_close_id})")
 
-        # 1. 关闭所有消费者通道
-        consumer_channels = []
+        # 1. 关闭消费者通道
+        channels_to_close = []
         async with self._lock:
-            consumer_channels = list(self._consumer_channels.values())
+            channels_to_close = list(self._consumer_channels.values())
             self._consumer_channels.clear()
-        for channel, _, _, _ in consumer_channels:
+
+        for ch in channels_to_close:
             try:
-                if not channel.is_closed:
-                    await channel.close()
+                if not ch.is_closed:
+                    await ch.close()
+                    logger.debug(f"✅ [CLOSE_CHANNEL] 消费者通道已关闭")
             except Exception as e:
-                logger.warning(f"关闭消费者通道失败: {str(e)}")
+                logger.warning(f"❌ [CLOSE_CHANNEL_ERR] 关闭消费者通道失败: {str(e)}")
 
-        # 2. 关闭主单通道
+        # 2. 关闭主通道
         if self._channel:
             try:
-                async with self._lock:
-                    if not self._channel.is_closed:
-                        await self._channel.close()
-            except Exception as e:
-                logger.warning(f"关闭主通道失败: {str(e)}")
+                if not self._channel.is_closed:
+                    await self._channel.close()
+                    logger.info(f"✅ [CLOSE_CHANNEL] 主通道已关闭")
+            except Exception:
+                pass
             self._channel = None
 
-        # 3. 关闭连接（终止原生自动重连）
+        # 3. 关闭连接
+        # 确保在 finally 或显式 close 中调用 connection.close()
         if self._connection:
             try:
-                async with self._lock:
-                    if not self._connection.is_closed:
-                        await self._connection.close()
-                logger.info(
-                    f"已关闭连接: {self._current_host}:{self.port}（终止原生自动重连）")
+                # 打印关闭操作
+                logger.info(f"🔌 [CLOSE_CONN] 正在关闭连接: {id(self._connection)}")
+                await self._connection.close()
+                logger.info(f"✅ [CLOSE_OK] 连接已成功关闭: {id(self._connection)}")
             except Exception as e:
-                logger.warning(f"关闭连接失败: {str(e)}")
+                logger.warning(f"❌ [CLOSE_ERR] 关闭连接失败: {str(e)}")
             self._connection = None
 
-        logger.info("RabbitMQ单通道客户端已完全关闭")
+        logger.info("🏁 [CLOSE_DONE] RabbitMQ客户端已完全关闭")
+
+    # --- 辅助方法省略 (declare_queue 等) ---
+    async def declare_queue(self, queue_name: str, **kwargs) -> AbstractQueue:
+        channel, _ = await self.acquire_channel()
+        return await channel.declare_queue(queue_name, **kwargs)
+
+    async def declare_exchange(self, exchange_name: str, exchange_type: str = "direct", **kwargs) -> AbstractExchange:
+        channel, _ = await self.acquire_channel()
+        return await channel.declare_exchange(exchange_name, exchange_type, **kwargs)

sycommon/rabbitmq/rabbitmq_service.py

@@ -1,11 +1,13 @@
 import asyncio
 import json
+import time
 from typing import (
     Callable, Coroutine, Dict, List, Optional, Type, Union, Any
 )
 from pydantic import BaseModel
 from aio_pika.abc import AbstractIncomingMessage, ConsumerTag
 
+from sycommon.config.Config import Config
 from sycommon.models.mqmsg_model import MQMsgModel
 from sycommon.models.mqlistener_config import RabbitMQListenerConfig
 from sycommon.models.mqsend_config import RabbitMQSendConfig
@@ -238,14 +240,16 @@ class RabbitMQService:
 
         app_name = kwargs.get('app_name', cls._config.get(
             "APP_NAME", "")) if cls._config else ""
-        is_sender = not cls._has_listeners
+        # 纯发送器场景（没有监听器），强制不创建队列
+        is_sender_only = not cls._has_listeners and cls._has_senders
 
-        # 根据组件类型决定是否允许创建队列
-        create_if_not_exists = cls._has_listeners  # 只有监听器允许创建队列
+        # 发送器场景下强制禁用队列创建
+        create_if_not_exists = False if is_sender_only else (
+            cls._has_listeners)
 
-        # 为监听器队列名称拼接应用名
         processed_queue_name = queue_name
-        if create_if_not_exists and not is_sender and processed_queue_name and app_name:
+        # 只有非纯发送器场景才处理队列名称拼接
+        if not is_sender_only and create_if_not_exists and processed_queue_name and app_name:
             if not processed_queue_name.endswith(f".{app_name}"):
                 processed_queue_name = f"{processed_queue_name}.{app_name}"
                 logger.info(f"监听器队列名称自动拼接app-name: {processed_queue_name}")
@@ -253,8 +257,9 @@ class RabbitMQService:
                 logger.info(f"监听器队列已包含app-name: {processed_queue_name}")
 
         logger.info(
-            f"创建客户端 - 队列: {processed_queue_name}, 发送器: {is_sender}, "
-            f"允许创建: {create_if_not_exists}"
+            f"创建客户端 - 队列: {processed_queue_name if not is_sender_only else 'N/A'}, "
+            f"纯发送器模式: {is_sender_only}, "
+            f"允许创建队列: {create_if_not_exists}"
         )
 
         # 创建客户端实例（适配精简版RabbitMQClient参数）
@@ -263,9 +268,12 @@ class RabbitMQService:
             exchange_name=cls._config.get(
                 'exchange_name', "system.topic.exchange"),
             exchange_type=kwargs.get('exchange_type', "topic"),
-            queue_name=processed_queue_name,
+            # 纯发送器场景下队列名称设为None，避免队列相关操作
+            queue_name=None if is_sender_only else processed_queue_name,
             routing_key=kwargs.get(
-                'routing_key', f"{processed_queue_name.split('.')[0]}.#" if processed_queue_name else "#"),
+                'routing_key',
+                f"{queue_name.split('.')[0]}.#" if queue_name and not is_sender_only else "#"
+            ),
             durable=kwargs.get('durable', True),
             auto_delete=kwargs.get('auto_delete', False),
             auto_parse_json=kwargs.get('auto_parse_json', True),
@@ -308,33 +316,32 @@ class RabbitMQService:
             # 如果客户端已存在且连接有效，直接返回
             if client_name in cls._clients:
                 client = cls._clients[client_name]
-                is_sender = not cls._has_listeners or (
-                    not kwargs.get('create_if_not_exists', True))
+                is_sender_only = not cls._has_listeners and cls._has_senders
 
                 if await client.is_connected:
-                    # 如果是监听器但队列未初始化，重新连接
-                    if not is_sender and not client._queue:
+                    # 只有非纯发送器场景才检查队列初始化状态
+                    if not is_sender_only and not client._queue and cls._has_listeners:
                         logger.info(f"客户端 '{client_name}' 队列未初始化，重新连接")
                         client.create_if_not_exists = True
                         await client.connect()
                     return client
                 else:
                     logger.info(f"客户端 '{client_name}' 连接已断开，重新连接")
-                    if not is_sender:
-                        client.create_if_not_exists = True
+                    if not is_sender_only:
+                        client.create_if_not_exists = cls._has_listeners
                     await client.connect()
                     return client
 
             # 创建新客户端
             initial_queue_name = kwargs.pop('queue_name', '')
-            is_sender = not cls._has_listeners or (
-                not kwargs.get('create_if_not_exists', True))
+            is_sender_only = not cls._has_listeners and cls._has_senders
 
-            # 发送器特殊处理
-            if is_sender:
+            # 发送器特殊处理 - 纯发送器场景强制不创建队列
+            if is_sender_only:
                 kwargs['create_if_not_exists'] = False
+                # 纯发送器场景下不传递队列名称，避免队列创建
                 client = await cls._create_client(
-                    initial_queue_name,
+                    "",  # 空队列名
                     app_name=cls._config.get("APP_NAME", ""),
                     **kwargs
                 )
@@ -351,8 +358,8 @@ class RabbitMQService:
                 **kwargs
             )
 
-            # 验证队列是否创建成功
-            if not client._queue:
+            # 只有非纯发送器场景才验证队列创建
+            if not is_sender_only and not client._queue:
                 logger.error(f"队列 '{initial_queue_name}' 创建失败，尝试重新创建")
                 client.create_if_not_exists = True
                 await client.connect()
@@ -371,7 +378,7 @@ class RabbitMQService:
 
         cls._has_senders = True
         cls._has_listeners = has_listeners
-        logger.info(f"开始设置 {len(senders)} 个消息发送器")
+        logger.info(f"开始设置 {len(senders)} 个消息发送器，纯发送器模式: {not has_listeners}")
 
         for idx, sender_config in enumerate(senders):
             try:
@@ -394,10 +401,12 @@ class RabbitMQService:
                     logger.info(f"发送客户端 '{normalized_name}' 已存在，跳过")
                     continue
 
-                # 获取或创建客户端
+                # 获取或创建客户端 - 强制禁用队列创建
                 if normalized_name in cls._clients:
                     client = cls._clients[normalized_name]
                     if not await client.is_connected:
+                        # 纯发送器场景下连接时也不创建队列
+                        client.create_if_not_exists = False
                         await client.connect()
                 else:
                     client = await cls.get_client(
@@ -407,7 +416,7 @@ class RabbitMQService:
                         auto_delete=sender_config.auto_delete,
                         auto_parse_json=sender_config.auto_parse_json,
                         queue_name=queue_name,
-                        create_if_not_exists=False,
+                        create_if_not_exists=False,  # 强制不创建队列
                         prefetch_count=prefetch_count,
                         **kwargs
                     )
@@ -419,13 +428,14 @@ class RabbitMQService:
 
                 if normalized_name not in cls._sender_client_names:
                     cls._sender_client_names.append(normalized_name)
-                    logger.info(f"发送客户端 '{normalized_name}' 初始化成功")
+                    logger.info(f"发送客户端 '{normalized_name}' 初始化成功（纯发送器模式）")
 
             except Exception as e:
                 logger.error(
                     f"初始化发送客户端第{idx+1}项失败: {str(e)}", exc_info=True)
 
-        logger.info(f"消息发送器设置完成，共 {len(cls._sender_client_names)} 个发送器")
+        logger.info(
+            f"消息发送器设置完成，共 {len(cls._sender_client_names)} 个发送器，纯发送器模式: {not has_listeners}")
 
     @classmethod
     async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False, **kwargs) -> None:
@@ -559,8 +569,8 @@ class RabbitMQService:
         handler = cls._message_handlers.get(client_name)
 
         if not handler:
-            logger.warning(f"未找到客户端 '{client_name}' 的处理器，使用默认处理器")
-            handler = cls.default_message_handler
+            logger.warning(f"未找到客户端 '{client_name}' 的处理器")
+            return
 
         # 设置消息处理器
         await client.set_message_handler(handler)
@@ -671,15 +681,6 @@ class RabbitMQService:
         task.add_done_callback(task_done_callback)
         logger.info(f"消费者任务 '{client_name}' 已创建")
 
-    @classmethod
-    async def default_message_handler(cls, parsed_data: MQMsgModel, original_message: AbstractIncomingMessage) -> None:
-        """默认消息处理器"""
-        logger.info(f"\n===== 收到消息 [{original_message.routing_key}] =====")
-        logger.info(f"关联ID: {parsed_data.correlationDataId}")
-        logger.info(f"主题代码: {parsed_data.topicCode}")
-        logger.info(f"消息内容: {parsed_data.msg}")
-        logger.info("===================\n")
-
     @classmethod
     async def get_sender(cls, queue_name: str) -> Optional[RabbitMQClient]:
         """获取发送客户端（适配单通道池）"""
@@ -699,6 +700,8 @@ class RabbitMQService:
             else:
                 logger.info(f"发送器 '{queue_name}' 连接已断开，尝试重连")
                 try:
+                    # 重连时也强制不创建队列
+                    client.create_if_not_exists = False
                     await client.connect()
                     if await client.is_connected:
                         return client
@@ -717,6 +720,8 @@ class RabbitMQService:
                 else:
                     logger.info(f"发送器 '{suffixed_name}' 连接已断开，尝试重连")
                     try:
+                        # 重连时也强制不创建队列
+                        client.create_if_not_exists = False
                         await client.connect()
                         if await client.is_connected:
                             return client
@@ -752,6 +757,8 @@ class RabbitMQService:
 
             while retry_count < max_retry and not cls._is_shutdown:
                 try:
+                    # 重连时强制不创建队列
+                    sender.create_if_not_exists = False
                     await sender.connect()
                     if await sender.is_connected:
                         logger.info(
@@ -792,16 +799,20 @@ class RabbitMQService:
             )
 
             # 构建消息头
+            namespaceId = Config().config.get('Nacos', {}).get('namespaceId', '未知环境')
+            tenant_id = "T000002" if namespaceId == "prod" or namespaceId == "wsuat1" else "T000003"
             mq_header = {
                 "context": SsoUser(
-                    tenant_id="T000002",
+                    tenant_id=tenant_id,
                     customer_id="SYSTEM",
                     user_id="SYSTEM",
                     user_name="SYSTEM",
-                    request_path="",
+                    request_path="/",
                     req_type="SYSTEM",
                     trace_id=logger.get_trace_id(),
-                ).model_dump_json()
+                ).model_dump_json(),
+                "tenant_id": logger.get_trace_id(),
+                "createTime": str(int(time.time() * 1000)),
             }
 
             # 发送消息（单通道场景下依赖原生异步确认）

{sycommon_python_lib-0.1.56b4.dist-info → sycommon_python_lib-0.1.56b6.dist-info}/METADATA

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

{sycommon_python_lib-0.1.56b4.dist-info → sycommon_python_lib-0.1.56b6.dist-info}/RECORD

@@ -46,9 +46,9 @@ sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
 sycommon/notice/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/notice/uvicorn_monitor.py,sha256=NRQVWs3jzZq9IY0M55s7LvOKtacsNpfCGGzH5071dGw,7181
-sycommon/rabbitmq/rabbitmq_client.py,sha256=GkuYILMZJnvgZs4ID46I-w_UGzzI28YUydKgkTIDhIs,20226
-sycommon/rabbitmq/rabbitmq_pool.py,sha256=QtUcK4HuepRqRmy5XkUQo8gDgj74fr77CX7T5rN0y4I,15640
-sycommon/rabbitmq/rabbitmq_service.py,sha256=wpEJynP0gzbnmMyB02sfR9nTWB4hfTTP00xQxDJu644,38119
+sycommon/rabbitmq/rabbitmq_client.py,sha256=jClUm9Ao9vZ2IZg7IXIEaDbYYnV8qtmtm77vdmwpKE4,22599
+sycommon/rabbitmq/rabbitmq_pool.py,sha256=5ruFVViSCKA7ToZmR2dZIkP0zT0ZcfsnkSGbrdkg0Tk,16141
+sycommon/rabbitmq/rabbitmq_service.py,sha256=yMNO2N3SxmkPs7jsyqja9EeDsirlxo_zJLDTHlwYB7A,39058
 sycommon/sse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/sse/event.py,sha256=k_rBJy23R7crtzQeetT0Q73D8o5-5p-eESGSs_BPOj0,2797
 sycommon/sse/sse.py,sha256=__CfWEcYxOxQ-HpLor4LTZ5hLWqw9-2X7CngqbVHsfw,10128
@@ -64,8 +64,8 @@ sycommon/tools/docs.py,sha256=OPj2ETheuWjXLyaXtaZPbwmJKfJaYXV5s4XMVAUNrms,1607
 sycommon/tools/merge_headers.py,sha256=HV_i52Q-9se3SP8qh7ZGYl8bP7Fxtal4CGVkyMwEdM8,4373
 sycommon/tools/snowflake.py,sha256=lVEe5mNCOgz5OqGQpf5_nXaGnRJlI2STX2s-ppTtanA,11947
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.56b4.dist-info/METADATA,sha256=c2XIy1w2EUZHGBPqJQvPTb6eYH2i5jTVNmnV-cPD-hs,7226
-sycommon_python_lib-0.1.56b4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.56b4.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.56b4.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.56b4.dist-info/RECORD,,
+sycommon_python_lib-0.1.56b6.dist-info/METADATA,sha256=LeQQG3OiyqTXd1H5AHtmaHXIut9tS3L3swY-a9FkSIs,7226
+sycommon_python_lib-0.1.56b6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.56b6.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.56b6.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.56b6.dist-info/RECORD,,