sycommon-python-lib 0.1.58__tar.gz → 0.2.0b0__tar.gz

{sycommon_python_lib-0.1.58 → sycommon_python_lib-0.2.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.58
+Version: 0.2.0b0
 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.58 → sycommon_python_lib-0.2.0b0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.58"
+version = "0.2.0b0"
 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.0b0/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.58 → sycommon_python_lib-0.2.0b0}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -117,7 +117,7 @@ class RabbitMQClient:
             logger.info(f"队列重建成功: {self.queue_name}")
 
     async def connect(self) -> None:
-        """连接方法（修复恢复消费失效问题）"""
+        """连接方法"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
@@ -125,9 +125,10 @@ class RabbitMQClient:
         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:
@@ -135,19 +136,16 @@ class RabbitMQClient:
                     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 +153,18 @@ class RabbitMQClient:
                 self._connect_condition.release()
             raise
 
-        # === 阶段 C: 执行耗时的连接逻辑 (此时已释放锁，不阻塞其他协程) ===
+        # === 阶段 C: 执行耗时的连接逻辑 (无锁状态) ===
+        connection_failed = False
+        was_consuming = False
+
+        # 用于追踪状态，避免在 except 中访问 self._x 导致的竞态
+        old_channel = self._channel
+
         try:
-            # --- 步骤 1: 记录旧状态并清理资源 ---
-            # 必须在清理前记录状态
+            # --- 步骤 1: 记录状态并清理旧资源 ---
             was_consuming = self._consumer_tag is not None
 
-            # 清理连接回调，防止旧的连接关闭触发新的重连
+            # 清理旧连接回调
             if self._channel_conn:
                 try:
                     if self._channel_conn.close_callbacks:
@@ -169,7 +172,14 @@ class RabbitMQClient:
                 except Exception:
                     pass
 
-            # 统一重置资源状态
+            # 显式关闭旧 Channel（这是 Client 自己创建的资源，必须关）
+            if old_channel and not old_channel.is_closed:
+                try:
+                    await old_channel.close()
+                except Exception:
+                    pass
+
+            # 重置引用
             self._channel = None
             self._channel_conn = None
             self._exchange = None
@@ -177,52 +187,68 @@ class RabbitMQClient:
             self._consumer_tag = None
 
             # --- 步骤 2: 获取新连接 ---
+            # 注意：如果这里抛出异常，说明 Pool 层面连接失败
             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: 重建基础资源 ---
             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
+
+            # 不要手动关闭 Pool 返回的连接，只置空引用。
             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("🔄 检测到重连前处于消费状态，尝试自动恢复消费...")
+                    try:
+                        self._consumer_tag = await self.start_consuming()
+                        logger.info(f"✅ 消费已自动恢复: {self._consumer_tag}")
+                    except Exception as e:
+                        logger.error(f"❌ 自动恢复消费失败: {e}")
+                        # 如果消费恢复失败，视为连接状态不完整，置空 Exchange
+                        self._consumer_tag = None
+                        self._exchange = None
+            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):
         """安全重连任务（仅用于被动监听连接关闭）"""
@@ -257,32 +283,14 @@ class RabbitMQClient:
 
     async def _process_message_callback(self, message: AbstractIncomingMessage):
         try:
-            msg_obj: MQMsgModel
-
-            # 1. 解析消息
-            if self.auto_parse_json:
-                try:
-                    body_dict = json.loads(message.body.decode("utf-8"))
-                    msg_obj = MQMsgModel(**body_dict)
-                    if not msg_obj.traceId:
-                        msg_obj.traceId = message.headers.get(
-                            "trace-id") if message.headers else SYLogger.get_trace_id()
-                except json.JSONDecodeError as e:
-                    logger.error(f"JSON解析失败: {e}")
-                    await message.reject(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") if message.headers else SYLogger.get_trace_id(),
-                )
+            body_dict = json.loads(message.body.decode("utf-8"))
+            msg_obj: MQMsgModel = MQMsgModel(**body_dict)
+            if not msg_obj.traceId:
+                msg_obj.traceId = message.headers.get(
+                    "trace-id") if message.headers else SYLogger.get_trace_id()
 
             SYLogger.set_trace_id(msg_obj.traceId)
 
-            # 3. 执行业务逻辑
             if self._message_handler:
                 await self._message_handler(msg_obj, message)
 
@@ -331,6 +339,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()
@@ -405,9 +418,12 @@ class RabbitMQClient:
         raise RuntimeError(f"消息发布最终失败: {last_exception}")
 
     async def close(self) -> None:
+        """关闭客户端（整合版：修复连接泄漏与死锁）"""
+        # 1. 先标记关闭，这会阻止 _safe_reconnect 和后续的 connect 逻辑
         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:
@@ -415,21 +431,43 @@ 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 锁
+        # 我们必须获取这个锁，以防止正在进行的 connect() 在我们清理资源时还在操作
+        # 但如果 connect 卡在 wait()，我们需要强制唤醒它
+        try:
+            # 尝试获取锁，设置超时防止死锁（虽然理论上我们即将 notify_all，但为了保险）
+            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
 
+            # 置空资源引用
             self._channel = None
             self._channel_conn = None
             self._exchange = None
             self._queue = None
             self._message_handler = None
+            self._conn_close_callback = None
 
-            # 确保唤醒可能正在等待 connect 的任务
+        finally:
+            # 【核心修复】无论是否成功获取锁，都要强制重置状态并唤醒所有等待者
+            # 这会让卡在 connect() 阶段 A 的 wait() 的协程醒来，发现 _closed=True 后抛出异常退出
             self._connecting = False
             self._connect_condition.notify_all()
 
+            # 确保锁被释放（如果持有）
+            if self._connect_condition.locked():
+                self._connect_condition.release()
+
         logger.info("客户端已关闭")