sycommon-python-lib 0.1.59__tar.gz → 0.2.0b1__tar.gz

{sycommon_python_lib-0.1.59 → sycommon_python_lib-0.2.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.59
+Version: 0.2.0b1
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -21,6 +21,7 @@ Requires-Dist: nacos-sdk-python<3.0,>=2.0.9
 Requires-Dist: psutil>=7.2.1
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: python-multipart>=0.0.21
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: sentry-sdk[fastapi]>=2.49.0
 Requires-Dist: sqlalchemy[asyncio]>=2.0.45

{sycommon_python_lib-0.1.59 → sycommon_python_lib-0.2.0b1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.59"
+version = "0.2.0b1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -22,6 +22,7 @@ dependencies = [
     "psutil>=7.2.1",
     "pydantic>=2.12.5",
     "python-dotenv>=1.2.1",
+    "python-multipart>=0.0.21",
     "pyyaml>=6.0.3",
     "sentry-sdk[fastapi]>=2.49.0",
     "sqlalchemy[asyncio]>=2.0.45",

sycommon_python_lib-0.2.0b1/src/sycommon/notice/uvicorn_monitor.py

@@ -0,0 +1,188 @@
+import sys
+import traceback
+import aiohttp
+import asyncio
+from typing import Optional
+from datetime import datetime
+from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
+from sycommon.config.Config import Config
+from sycommon.logging.kafka_log import SYLogger
+
+
+async def send_wechat_markdown_msg(
+    content: str,
+    webhook: str = None
+) -> Optional[dict]:
+    """
+    异步发送企业微信Markdown格式的WebHook消息
+    """
+    # 构造请求体（Markdown格式）
+    payload = {
+        "msgtype": "markdown",
+        "markdown": {
+            "content": content
+        }
+    }
+
+    try:
+        # 使用 json 参数自动处理序列化和 Content-Type
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                url=webhook,
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=10)
+            ) as response:
+                response_data = await response.json()
+
+                if response.status == 200 and response_data.get("errcode") == 0:
+                    SYLogger.info(f"消息发送成功: {response_data}")
+                    return response_data
+                else:
+                    SYLogger.warning(
+                        f"消息发送失败 - 状态码: {response.status}, 响应: {response_data}")
+                    return None
+    except Exception as e:
+        SYLogger.error(f"发送企业微信消息异常: {str(e)}")
+        return None
+
+
+async def send_webhook(error_info: dict = None, webhook: str = None):
+    """
+    发送服务启动结果的企业微信通知
+    """
+    # 获取服务名和环境（增加默认值保护）
+    try:
+        config = Config().config
+        service_name = config.get('Name', "未知服务")
+        env = config.get('Nacos', {}).get('namespaceId', '未知环境')
+        # 注意：这里使用了大写开头的 WebHook，请确保配置文件中键名一致
+        webHook = config.get('llm', {}).get('WebHook')
+    except Exception as e:
+        service_name = "未知服务"
+        env = "未知环境"
+        webHook = None
+        SYLogger.warning(f"读取配置失败: {str(e)}")
+
+    start_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+    # 如果没有错误信息，就不发送失败告警
+    if not error_info:
+        return
+
+    # 启动失败的通知内容（包含详细错误信息）
+    error_type = error_info.get("error_type", "未知错误")
+    error_msg = error_info.get("error_msg", "无错误信息")
+    stack_trace = error_info.get("stack_trace", "无堆栈信息")[:1000]  # 适当增加长度限制
+    elapsed_time = error_info.get("elapsed_time", 0)
+
+    markdown_content = f"""### {service_name}服务启动失败告警 ⚠️
+> 环境: <font color="warning">{env}</font>
+> 启动时间: <font color="comment">{start_time}</font>
+> 耗时: <font color="comment">{elapsed_time:.2f}秒</font>
+> 错误类型: <font color="danger">{error_type}</font>
+> 错误信息: <font color="danger">{error_msg}</font>
+> 错误堆栈: {stack_trace}"""
+
+    if webhook or webHook:
+        result = await send_wechat_markdown_msg(
+            content=markdown_content,
+            webhook=webhook or webHook
+        )
+        SYLogger.info(f"通知发送结果: {result}")
+    else:
+        SYLogger.info("未设置企业微信WebHook，跳过告警发送")
+
+
+def run(*args, webhook: str = None, **kwargs):
+    """
+    带企业微信告警的Uvicorn启动监控
+    """
+    # 判断环境
+    try:
+        env = Config().config.get('Nacos', {}).get('namespaceId', 'dev')
+    except:
+        env = 'dev'
+
+    # 如果是生产环境，通常不需要这种启动脚本进行告警干扰，或者你需要根据实际情况调整
+    if env == "prod":
+        import uvicorn
+        uvicorn.run(*args, **kwargs)
+        return
+
+    # 记录启动开始时间
+    start_time = datetime.now()
+
+    if webhook:
+        # 脱敏展示webhook
+        try:
+            parsed = urlparse(webhook)
+            query = parse_qs(parsed.query)
+            if 'key' in query and query['key'][0]:
+                key = query['key'][0]
+                masked_key = key[:8] + "****" if len(key) > 8 else key + "****"
+                query['key'] = [masked_key]
+                masked_query = urlencode(query, doseq=True)
+                masked_webhook = urlunparse(
+                    (parsed.scheme, parsed.netloc, parsed.path, parsed.params, masked_query, parsed.fragment))
+                SYLogger.info(f"自定义企业微信WebHook: {masked_webhook}")
+        except Exception:
+            SYLogger.info("自定义Webhook格式解析失败，但会尝试使用")
+
+    # 初始化错误信息
+    error_info = None
+
+    try:
+        import uvicorn
+        # 执行启动
+        uvicorn.run(*args, **kwargs)
+
+    except KeyboardInterrupt:
+        # 处理用户手动中断
+        elapsed = (datetime.now() - start_time).total_seconds()
+        SYLogger.info(f"\n{'='*50}")
+        SYLogger.info(f"ℹ️  应用被用户手动中断")
+        SYLogger.info(f"启动耗时: {elapsed:.2f} 秒")
+        SYLogger.info(f"{'='*50}\n")
+        # 手动中断不需要错误告警，也不需要 sys.exit(1)
+        sys.exit(0)
+
+    except Exception as e:
+        # 捕获启动失败异常
+        elapsed = (datetime.now() - start_time).total_seconds()
+        stack_trace = traceback.format_exc()
+
+        error_info = {
+            "error_type": type(e).__name__,
+            "error_msg": str(e),
+            "stack_trace": stack_trace,
+            "elapsed_time": elapsed
+        }
+
+        # 打印详细错误
+        SYLogger.error(f"\n{'='*50}")
+        SYLogger.error(f"🚨 应用启动失败！")
+        SYLogger.error(f"失败时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        SYLogger.error(f"错误类型: {type(e).__name__}")
+        SYLogger.error(f"错误信息: {str(e)}")
+        SYLogger.error(f"\n📝 错误堆栈:")
+        SYLogger.error(f"-"*50)
+        traceback.print_exc(file=sys.stdout)
+        SYLogger.error(f"\n⏱️  启动耗时: {elapsed:.2f} 秒")
+        SYLogger.error(f"{'='*50}\n")
+
+    finally:
+        # 创建新的事件循环来发送通知，防止与 Uvicorn 的循环冲突
+        if error_info:
+            try:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                loop.run_until_complete(send_webhook(
+                    error_info=error_info,
+                    webhook=webhook
+                ))
+                loop.close()
+            except Exception as e:
+                SYLogger.error(f"错误：异步通知发送失败 - {str(e)}")
+
+            # 只有确实有错误时才以状态码 1 退出
+            sys.exit(1)

{sycommon_python_lib-0.1.59 → sycommon_python_lib-0.2.0b1}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -117,37 +117,37 @@ class RabbitMQClient:
             logger.info(f"队列重建成功: {self.queue_name}")
 
     async def connect(self) -> None:
-        """连接方法（修复恢复消费失效问题）"""
+        """连接方法（消费者独立通道 + 移除无效属性检查 + 强制重建队列）"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
-        # 1. 获取 Condition 锁
+        # 1. 获取 Condition 锁，用于管理连接并发和等待
         await self._connect_condition.acquire()
 
         try:
-            # ===== 阶段 A: 快速检查与等待 =====
+            # ===== 阶段 A: 检查状态与排队 =====
             if await self.is_connected:
-                self._connect_condition.release()
+                if self._connect_condition.locked():
+                    self._connect_condition.release()
                 return
 
+            # 如果已有协程正在连接，等待其完成
             if self._connecting:
                 try:
                     logger.debug("连接正在进行中，等待现有连接完成...")
                     await asyncio.wait_for(self._connect_condition.wait(), timeout=60.0)
                 except asyncio.TimeoutError:
-                    self._connect_condition.release()
-                    raise RuntimeError("等待连接超时")
+                    logger.warning("等待前序连接超时，当前协程将尝试强制接管并重连...")
 
+                # 唤醒后再次检查状态，防止重复连接
                 if await self.is_connected:
-                    self._connect_condition.release()
+                    if self._connect_condition.locked():
+                        self._connect_condition.release()
                     return
-                else:
-                    self._connect_condition.release()
-                    raise RuntimeError("等待重连后，连接状态依然无效")
 
-            # ===== 阶段 B: 标记开始连接 =====
+            # ===== 阶段 B: 标记开始连接并释放锁 =====
+            # 释放锁是为了让耗时的连接过程不阻塞其他协程
             self._connecting = True
-            # 【关键】释放锁，允许其他协程进入等待逻辑
             self._connect_condition.release()
 
         except Exception as e:
@@ -155,13 +155,19 @@ class RabbitMQClient:
                 self._connect_condition.release()
             raise
 
-        # === 阶段 C: 执行耗时的连接逻辑 (此时已释放锁，不阻塞其他协程) ===
+        # === 阶段 C: 执行耗时的连接逻辑 (无锁状态) ===
+        connection_failed = False
+        was_consuming = False
+
+        # 判断当前是否为消费者模式（通过是否有消息处理函数判断）
+        is_consumer = self._message_handler is not None
+        old_channel = self._channel
+
         try:
-            # --- 步骤 1: 记录旧状态并清理资源 ---
-            # 必须在清理前记录状态
+            # --- 步骤 1: 记录状态并清理旧资源 ---
             was_consuming = self._consumer_tag is not None
 
-            # 清理连接回调，防止旧的连接关闭触发新的重连
+            # 清理旧连接的 close_callbacks，防止重连触发多次
             if self._channel_conn:
                 try:
                     if self._channel_conn.close_callbacks:
@@ -169,60 +175,125 @@ class RabbitMQClient:
                 except Exception:
                     pass
 
-            # 统一重置资源状态
+            # 显式关闭旧 Channel
+            # 注意：无论是生产者复用的主通道，还是消费者的独立通道，断开时都应显式关闭以释放服务端资源
+            if old_channel and not old_channel.is_closed:
+                try:
+                    await old_channel.close()
+                except Exception:
+                    pass
+
+            # 【修复点】强制重置所有核心资源引用
+            # 因为我们即将获取一个新的 Channel，旧的 Exchange 和 Queue 对象（基于旧 Channel）将全部失效。
+            # 必须置为 None，强制后续逻辑基于新 Channel 重建这些对象。
             self._channel = None
             self._channel_conn = None
             self._exchange = None
             self._queue = None
             self._consumer_tag = None
 
-            # --- 步骤 2: 获取新连接 ---
-            self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
+            # --- 步骤 2: 根据角色获取新连接 ---
+            # 生产者：复用连接池的主通道（性能高）
+            # 消费者：从连接池获取独立的通道（稳定性高，避免并发冲突）
+            if is_consumer:
+                logger.debug("获取消费者独立通道...")
+                self._channel = await self.connection_pool.acquire_consumer_channel()
+                self._channel_conn = self.connection_pool._connection
+            else:
+                logger.debug("获取生产者主通道...")
+                self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
+
+            # --- 步骤 3: 设置连接关闭回调 ---
+            loop = asyncio.get_running_loop()
 
-            # 设置连接关闭回调
             def on_conn_closed(conn, exc):
+                if self._closed:
+                    return
                 logger.warning(f"检测到底层连接关闭: {exc}")
-                if not self._closed and not self._connecting:
-                    asyncio.create_task(self._safe_reconnect())
+                # 确保在循环中安全调用协程
+                asyncio.run_coroutine_threadsafe(self._safe_reconnect(), loop)
 
             if self._channel_conn:
                 self._channel_conn.close_callbacks.add(on_conn_closed)
 
-            # --- 步骤 3: 重建基础资源 (交换机和队列) ---
+            # --- 步骤 4: 重建基础资源 ---
+            # 这会在新的 self._channel 上声明 Exchange 和 Queue，并执行绑定
             await self._rebuild_resources()
 
-            # --- 步骤 4: 恢复消费 ---
-            if was_consuming and self._message_handler:
-                logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复消费...")
-                try:
-                    # 直接调用 start_consuming 来恢复，它内部包含了完整的队列检查和绑定逻辑
-                    self._consumer_tag = await self.start_consuming()
-                    logger.info(f"✅ 消费已自动恢复: {self._consumer_tag}")
-                except Exception as e:
-                    logger.error(f"❌ 自动恢复消费失败: {e}")
-                    self._consumer_tag = None
-
-            logger.info("客户端连接初始化完成")
-
         except Exception as e:
+            connection_failed = True
             logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
-            # 异常时彻底清理
+
+            # 发生异常时清理引用
             if self._channel_conn and self._channel_conn.close_callbacks:
                 self._channel_conn.close_callbacks.clear()
+
             self._channel = None
             self._channel_conn = None
+            self._exchange = None
             self._queue = None
             self._consumer_tag = None
+
             raise
 
         finally:
-            # === 阶段 D: 恢复状态并通知 ===
-            await self._connect_condition.acquire()
+            # === 阶段 D: 恢复消费与收尾 (重新加锁) ===
             try:
+                await self._connect_condition.acquire()
+            except Exception:
+                pass
+
+            try:
+                # 只有连接完全成功，且之前处于消费状态，才尝试自动恢复消费
+                if not connection_failed and was_consuming and self._message_handler:
+                    logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复消费...")
+
+                    # 【修复核心】
+                    # 由于在步骤 1 中 self._queue 已被置为 None，
+                    # 如果 _rebuild_resources 因为某种原因（例如配置条件）没有成功创建队列，
+                    # 这里需要再次尝试在当前新 Channel 上创建并绑定队列。
+                    # 不再检查 is_closed（因为该属性不存在），直接检查是否为 None。
+
+                    if self.queue_name and not self._queue:
+                        try:
+                            logger.info(f"重连恢复过程中重新声明队列: {self.queue_name}")
+                            # 在当前新 Channel 上声明队列
+                            self._queue = await self._channel.declare_queue(
+                                name=self.queue_name,
+                                durable=self.durable,
+                                auto_delete=self.auto_delete,
+                                passive=not self.create_if_not_exists,
+                            )
+
+                            # 【关键步骤】显式绑定队列
+                            # 即使队列已存在，也必须在新 Channel 上重新绑定，否则服务端路由状态可能不更新
+                            if self._exchange:
+                                await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+                                logger.info(
+                                    f"✅ 重连绑定成功: {self.queue_name} -> {self.routing_key}")
+                        except Exception as bind_err:
+                            logger.error(f"❌ 重连恢复队列/绑定失败: {bind_err}")
+                            # 绑定失败，无法恢复消费
+                            self._queue = None
+
+                    # 队列对象有效才启动消费
+                    if self._queue:
+                        try:
+                            self._consumer_tag = await self.start_consuming()
+                            logger.info(f"✅ 消费已自动恢复: {self._consumer_tag}")
+                        except Exception as e:
+                            logger.error(f"❌ 自动恢复消费失败: {e}")
+                            self._consumer_tag = None
+                    else:
+                        logger.warning("⚠️ 队列对象无效，无法恢复消费")
+
+            finally:
+                # 最终状态复位
                 self._connecting = False
                 self._connect_condition.notify_all()
-            finally:
-                self._connect_condition.release()
+
+                if self._connect_condition.locked():
+                    self._connect_condition.release()
 
     async def _safe_reconnect(self):
         """安全重连任务（仅用于被动监听连接关闭）"""
@@ -313,6 +384,11 @@ class RabbitMQClient:
             self._consumer_tag = None
 
     async def _handle_publish_failure(self):
+        # 如果当前正在重连，或者已经关闭，直接返回，避免冲突
+        if self._connecting or self._closed:
+            logger.warning("⚠️ 正在重连或已关闭，跳过故障转移触发")
+            return
+
         try:
             logger.info("检测到发布异常，强制连接池切换节点...")
             await self.connection_pool.force_reconnect()
@@ -387,9 +463,12 @@ class RabbitMQClient:
         raise RuntimeError(f"消息发布最终失败: {last_exception}")
 
     async def close(self) -> None:
+        """关闭客户端（支持独立通道的清理与死锁修复）"""
+        # 1. 先标记关闭
         self._closed = True
         logger.info("开始关闭RabbitMQ客户端...")
 
+        # 2. 取消可能存在的后台重连任务
         if self._current_reconnect_task and not self._current_reconnect_task.done():
             self._current_reconnect_task.cancel()
             try:
@@ -397,21 +476,53 @@ class RabbitMQClient:
             except asyncio.CancelledError:
                 pass
 
+        # 3. 停止消费
         await self.stop_consuming()
 
-        async with self._connect_lock:
-            if self._conn_close_callback and self._channel_conn:
-                self._channel_conn.close_callbacks.discard(
-                    self._conn_close_callback)
+        # 4. 处理 _connect_condition 锁
+        try:
+            await asyncio.wait_for(self._connect_condition.acquire(), timeout=2.0)
+        except asyncio.TimeoutError:
+            logger.warning("获取连接锁超时，强制清理资源...")
+
+        try:
+            # 清理回调
+            if self._channel_conn:
+                try:
+                    if self._channel_conn.close_callbacks:
+                        self._channel_conn.close_callbacks.clear()
+                except Exception:
+                    pass
+
+            # 【关键修改】显式关闭持有的通道
+            # 无论是生产者（主通道，但 Client 只是持有者，通常不关 Pool 管理的主通道），
+            # 还是消费者（独立通道，必须显式关闭），这里都需要处理。
+            # 由于我们引入了独立消费者通道，这里必须显式关闭 self._channel
+            if self._channel and not self._channel.is_closed:
+                try:
+                    # 注意：如果是主通道，这里关闭可能会影响其他 Producer。
+                    # 但由于我们的架构中，Consumer 用独立通道，这里大概率是 Consumer 关闭。
+                    # 为了安全，可以增加判断：如果 shared_channel 标志为 False 才关？
+                    # 简化策略：统一关闭，因为 Client 被销毁意味着不再需要该通道。
+                    await self._channel.close()
+                    logger.debug("客户端通道已关闭")
+                except Exception as e:
+                    logger.warning(f"关闭客户端通道异常: {e}")
 
+            # 置空资源引用
             self._channel = None
             self._channel_conn = None
             self._exchange = None
             self._queue = None
             self._message_handler = None
+            self._conn_close_callback = None
 
-            # 确保唤醒可能正在等待 connect 的任务
+        finally:
+            # 强制重置状态并唤醒所有等待者
             self._connecting = False
             self._connect_condition.notify_all()
 
+            if self._connect_condition.locked():
+                self._connect_condition.release()
+
         logger.info("客户端已关闭")