sycommon-python-lib 0.1.31__py3-none-any.whl → 0.1.32__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_client.py

@@ -102,7 +102,7 @@ class RabbitMQClient:
         self._monitor_task: Optional[asyncio.Task] = None
 
         # 消息处理跟踪
-        self._processing_message_ids: Set[str] = set()
+        self._tracking_messages: Dict[str, Dict[str, Any]] = {}
 
     @property
     def is_connected(self) -> bool:
@@ -189,7 +189,7 @@ class RabbitMQClient:
         """
         从连接池获取资源并初始化（交换机、队列）
         """
-        logger.debug(
+        logger.info(
             f"连接参数 - force_reconnect={force_reconnect}, "
             f"declare_queue={declare_queue}, create_if_not_exists={self.create_if_not_exists}"
         )
@@ -275,7 +275,7 @@ class RabbitMQClient:
                     # 不声明队列时的状态处理
                     self.queue = None
                     self.actual_queue_name = None
-                    logger.debug(f"跳过队列 '{self.queue_name}' 的声明和绑定")
+                    logger.info(f"跳过队列 '{self.queue_name}' 的声明和绑定")
 
                 # 验证连接状态
                 if not self.is_connected:
@@ -320,13 +320,27 @@ class RabbitMQClient:
                         await self._recreate_channel()
                         continue
 
+                    # 清理已确认的消息记录
+                    if self._tracking_messages:
+                        # 收集所有已确认的消息ID
+                        acked_message_ids = [
+                            msg_id for msg_id, msg_info in self._tracking_messages.items()
+                            if msg_info.get('acked', False)
+                        ]
+                        # 移除已确认的消息
+                        for msg_id in acked_message_ids:
+                            del self._tracking_messages[msg_id]
+                        if acked_message_ids:
+                            logger.info(
+                                f"清理了 {len(acked_message_ids)} 条已确认的消息跟踪记录")
+
                     # 检查消费停滞
                     if self._is_consuming:
                         current_time = asyncio.get_event_loop().time()
                         if current_time - self._last_message_processed > self.consumption_stall_threshold:
-                            if self._processing_message_ids:
-                                logger.warning(
-                                    f"消费停滞，但有 {len(self._processing_message_ids)} 个消息正在处理，暂不重启")
+                            if self._tracking_messages:
+                                logger.info(
+                                    f"消费停滞，但有 {len(self._tracking_messages)} 个消息正在处理，暂不重启")
                             else:
                                 # 确实无消息处理，再重启
                                 await self.stop_consuming()
@@ -336,7 +350,7 @@ class RabbitMQClient:
                     logger.error(f"监控任务出错: {str(e)}")
                     await asyncio.sleep(1)
 
-                await asyncio.sleep(30)
+                await asyncio.sleep(60)
 
         self._monitor_task = asyncio.create_task(monitor())
 
@@ -375,7 +389,7 @@ class RabbitMQClient:
                 current_time = asyncio.get_event_loop().time()
                 # 检查是否超过指定时间无活动
                 if current_time - self._last_activity_timestamp > self.connection_pool.heartbeat * 1.5:
-                    logger.debug(
+                    logger.info(
                         f"连接 {self.connection_pool.heartbeat*1.5}s 无活动，执行保活检查")
                     try:
                         if self.channel.is_closed:
@@ -440,7 +454,7 @@ class RabbitMQClient:
         self.exchange = None
         self.queue = None
         self._consumer_tag = None
-        self._processing_message_ids.clear()
+        self._tracking_messages.clear()
 
         logger.info("RabbitMQ客户端已关闭")
 
@@ -488,13 +502,13 @@ class RabbitMQClient:
                         message,
                         routing_key=routing_key or self.routing_key or '#',
                         mandatory=True,
-                        timeout=15.0
+                        timeout=5.0
                     )
                     if not confirmed:
                         raise Exception("消息未被服务器确认接收")
 
                 self._update_activity_timestamp()
-                logger.debug(f"消息已发布到交换机 '{self.exchange_name}'")
+                logger.info(f"消息已发布到交换机 '{self.exchange_name}'")
                 return
             except (ConnectionClosed, ChannelInvalidStateError):
                 retry_count += 1
@@ -514,7 +528,7 @@ class RabbitMQClient:
 
     async def start_consuming(self) -> ConsumerTag:
         if self._is_consuming:
-            logger.debug("已经在消费中，返回现有consumer_tag")
+            logger.info("已经在消费中，返回现有consumer_tag")
             if self._consumer_tag:
                 return self._consumer_tag
             # 如果_is_consuming为True但无consumer_tag，重置状态并重新启动
@@ -577,15 +591,15 @@ class RabbitMQClient:
             await self._safe_cancel_consumer()
 
         # 等待所有正在处理的消息完成
-        if self._processing_message_ids:
+        if self._tracking_messages:
             logger.info(
-                f"等待 {len(self._processing_message_ids)} 个正在处理的消息完成...")
-            while self._processing_message_ids and not self._closed:
-                await asyncio.sleep(0.1)
+                f"等待 {len(self._tracking_messages)} 个正在处理的消息完成...")
+            while self._tracking_messages and not self._closed:
+                await asyncio.sleep(1)
 
         # 清理状态
         self._consumer_tag = None
-        self._processing_message_ids.clear()
+        self._tracking_messages.clear()
 
         logger.info(f"已停止消费队列: {self.actual_queue_name}")
 
@@ -615,23 +629,29 @@ class RabbitMQClient:
             return
 
         message_id = message.message_id or str(id(message))
-        if message_id in self._processing_message_ids:
+        if message_id in self._tracking_messages:
             logger.warning(f"检测到重复处理的消息ID: {message_id}，直接确认")
             await message.ack()
             return
 
-        self._processing_message_ids.add(message_id)
+        # 记录消息跟踪信息
+        self._tracking_messages[message_id] = {
+            'delivery_tag': message.delivery_tag,
+            'acked': False,
+            'channel_number': self.channel.number if self.channel else None
+        }
 
         try:
-            logger.debug(f"收到队列 {self.actual_queue_name} 的消息: {message_id}")
+            logger.info(f"收到队列 {self.actual_queue_name} 的消息: {message_id}")
 
             parsed_data = await self._parse_message(message)
             await self.message_handler(MQMsgModel(** parsed_data), message)
 
             await message.ack()
+            self._tracking_messages[message_id]['acked'] = True  # 更新ACK状态
             self._update_activity_timestamp()
             self._update_message_processed_timestamp()
-            logger.debug(f"消息 {message_id} 处理完成并确认")
+            logger.info(f"消息 {message_id} 处理完成并确认")
 
         except Exception as e:
             current_headers = message.headers or {}
@@ -647,6 +667,7 @@ class RabbitMQClient:
                 logger.error(
                     f"消息 {message_id} 已达到最大重试次数({MAX_RETRY_COUNT}次)，标记为失败")
                 await message.ack()
+                self._tracking_messages[message_id]['acked'] = True  # 更新ACK状态
                 self._update_activity_timestamp()
                 return
 
@@ -661,6 +682,7 @@ class RabbitMQClient:
             )
 
             await message.reject(requeue=False)
+            self._tracking_messages[message_id]['acked'] = True  # 拒绝也算处理完成
 
             if self.exchange:
                 await self.exchange.publish(
@@ -672,8 +694,8 @@ class RabbitMQClient:
                 self._update_activity_timestamp()
                 logger.info(f"消息 {message_id} 已重新发布，当前重试次数: {retry_count}")
         finally:
-            if message_id in self._processing_message_ids:
-                self._processing_message_ids.remove(message_id)
+            if message_id in self._tracking_messages:
+                del self._tracking_messages[message_id]
 
     async def __aenter__(self):
         await self.connect()

sycommon/rabbitmq/rabbitmq_service.py

@@ -142,7 +142,7 @@ class RabbitMQService:
             else:
                 logger.info(f"监听器队列已包含app-name: {processed_queue_name}")
 
-        logger.debug(
+        logger.info(
             f"创建客户端 - 队列: {processed_queue_name}, 发送器: {is_sender}, "
             f"允许创建: {create_if_not_exists}"
         )
@@ -161,7 +161,7 @@ class RabbitMQService:
             auto_parse_json=kwargs.get('auto_parse_json', True),
             create_if_not_exists=create_if_not_exists,
             connection_timeout=kwargs.get('connection_timeout', 10),
-            rpc_timeout=kwargs.get('rpc_timeout', 5),
+            rpc_timeout=kwargs.get('rpc_timeout', 10),
             reconnection_delay=kwargs.get('reconnection_delay', 1),
             max_reconnection_attempts=kwargs.get(
                 'max_reconnection_attempts', 5),
@@ -207,12 +207,12 @@ class RabbitMQService:
                 if client.is_connected:
                     # 如果是监听器但队列未初始化，重新连接
                     if not is_sender and not client.queue:
-                        logger.debug(f"客户端 '{client_name}' 队列未初始化，重新连接")
+                        logger.info(f"客户端 '{client_name}' 队列未初始化，重新连接")
                         client.create_if_not_exists = True
                         await client.connect(force_reconnect=True, declare_queue=True)
                     return client
                 else:
-                    logger.debug(f"客户端 '{client_name}' 连接已关闭，重新连接")
+                    logger.info(f"客户端 '{client_name}' 连接已关闭，重新连接")
                     if not is_sender:
                         client.create_if_not_exists = True
                     await client.connect(declare_queue=not is_sender)
@@ -240,7 +240,7 @@ class RabbitMQService:
 
             # 检查队列是否已初始化
             if initial_queue_name in cls._initialized_queues:
-                logger.debug(f"队列 '{initial_queue_name}' 已初始化，直接创建客户端")
+                logger.info(f"队列 '{initial_queue_name}' 已初始化，直接创建客户端")
                 client = await cls._create_client(
                     initial_queue_name, ** kwargs
                 )
@@ -296,11 +296,11 @@ class RabbitMQService:
                 normalized_name = queue_name
                 if app_name and normalized_name.endswith(f".{app_name}"):
                     normalized_name = normalized_name[:-len(f".{app_name}")]
-                    logger.debug(f"发送器队列名称移除app-name后缀: {normalized_name}")
+                    logger.info(f"发送器队列名称移除app-name后缀: {normalized_name}")
 
                 # 检查是否已初始化
                 if normalized_name in cls._sender_client_names:
-                    logger.debug(f"发送客户端 '{normalized_name}' 已存在，跳过")
+                    logger.info(f"发送客户端 '{normalized_name}' 已存在，跳过")
                     continue
 
                 # 获取或创建客户端
@@ -405,7 +405,7 @@ class RabbitMQService:
             raise ValueError("RabbitMQService尚未初始化，请先调用init方法")
 
         if queue_name in cls._message_handlers:
-            logger.debug(f"监听器 '{queue_name}' 已存在，跳过重复添加")
+            logger.info(f"监听器 '{queue_name}' 已存在，跳过重复添加")
             return
 
         # 创建并初始化客户端
@@ -429,7 +429,7 @@ class RabbitMQService:
     async def start_consumer(cls, client_name: str) -> None:
         """启动指定客户端的消费者"""
         if client_name in cls._consumer_tasks and not cls._consumer_tasks[client_name].done():
-            logger.debug(f"消费者 '{client_name}' 已在运行中，无需重复启动")
+            logger.info(f"消费者 '{client_name}' 已在运行中，无需重复启动")
             return
 
         if client_name not in cls._clients:
@@ -451,7 +451,7 @@ class RabbitMQService:
             if asyncio.get_event_loop().time() - start_time > cls.CONSUMER_START_TIMEOUT:
                 raise TimeoutError(f"等待客户端 '{client_name}' 连接超时")
 
-            logger.debug(f"等待客户端 '{client_name}' 连接就绪...")
+            logger.info(f"等待客户端 '{client_name}' 连接就绪...")
             await asyncio.sleep(1)
 
         # 创建停止事件
@@ -557,7 +557,7 @@ class RabbitMQService:
         if app_name and f"{queue_name}.{app_name}" in cls._sender_client_names:
             return cls._clients.get(f"{queue_name}.{app_name}")
 
-        logger.debug(f"未找到发送器 '{queue_name}'")
+        logger.info(f"未找到发送器 '{queue_name}'")
         return None
 
     @classmethod
@@ -651,7 +651,7 @@ class RabbitMQService:
             raise
 
     @classmethod
-    async def shutdown(cls, timeout: float = 10.0) -> None:
+    async def shutdown(cls, timeout: float = 15.0) -> None:
         """优雅关闭所有资源（新增连接池关闭逻辑）"""
         start_time = asyncio.get_event_loop().time()
         logger.info("开始关闭RabbitMQ服务...")

{sycommon_python_lib-0.1.31.dist-info → sycommon_python_lib-0.1.32.dist-info}/METADATA

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

{sycommon_python_lib-0.1.31.dist-info → sycommon_python_lib-0.1.32.dist-info}/RECORD

@@ -35,9 +35,9 @@ sycommon/models/mqlistener_config.py,sha256=vXp2uMmd0XQ5B9noSRXWHewTy-juQ2y7IsWt
 sycommon/models/mqmsg_model.py,sha256=cxn0M5b0utQK6crMYmL-1waeGYHvK3AlGaRy23clqTE,277
 sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6D7I,268
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
-sycommon/rabbitmq/rabbitmq_client.py,sha256=a91aWJ1ttVmMrfXGTBkoSuNgpsTHbQvuEjozswBp_Yk,27260
+sycommon/rabbitmq/rabbitmq_client.py,sha256=TSeUItuPLbCCkQhsc81Cz3qcGATiTaZhtkiRxdhi72o,28407
 sycommon/rabbitmq/rabbitmq_pool.py,sha256=_NMOO4CZy-I_anMqpzfYinz-8373_rg5FM9eqzdjGyU,3598
-sycommon/rabbitmq/rabbitmq_service.py,sha256=5a6F4RlzRYLbDm0qJSx9BMfvOIzwSQsiA7T-oAROZ5k,30172
+sycommon/rabbitmq/rabbitmq_service.py,sha256=1htwoA27uRVU-Vzgezonq95iBE1tGVi4poRw8qX2-ls,30163
 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
@@ -52,8 +52,8 @@ sycommon/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/tools/docs.py,sha256=OPj2ETheuWjXLyaXtaZPbwmJKfJaYXV5s4XMVAUNrms,1607
 sycommon/tools/snowflake.py,sha256=DdEj3T5r5OEvikp3puxqmmmz6BrggxomoSlnsRFb5dM,1174
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.31.dist-info/METADATA,sha256=egvprkvuPRH0lVt9bM2SwWS-5dvTA_TrHXYvvSah4QY,7037
-sycommon_python_lib-0.1.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.31.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.31.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.31.dist-info/RECORD,,
+sycommon_python_lib-0.1.32.dist-info/METADATA,sha256=0a2NR7XmC94hHtEK3o0ipLLcROts-tv4anODwKYUUrY,7037
+sycommon_python_lib-0.1.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.32.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.32.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.32.dist-info/RECORD,,