sycommon-python-lib 0.1.56__py3-none-any.whl → 0.1.56b2__py3-none-any.whl

sycommon/notice/uvicorn_monitor.py

@@ -1,200 +0,0 @@
-from datetime import datetime
-import sys
-import traceback
-import aiohttp
-import asyncio
-import json
-from typing import Optional
-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消息
-
-    Args:
-        content: Markdown格式的消息内容（支持企业微信支持的markdown语法）
-        webhook: 完整的企业微信WebHook URL（默认值包含key）
-
-    Returns:
-        接口返回的JSON数据（dict），失败返回None
-    """
-    # 设置请求头
-    headers = {
-        "Content-Type": "application/json; charset=utf-8"
-    }
-
-    # 构造请求体（Markdown格式）
-    payload = {
-        "msgtype": "markdown",
-        "markdown": {
-            "content": content
-        }
-    }
-
-    try:
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                url=webhook,
-                data=json.dumps(payload, ensure_ascii=False),
-                headers=headers,
-                timeout=aiohttp.ClientTimeout(total=10)
-            ) as response:
-                status = response.status
-                response_text = await response.text()
-                response_data = json.loads(
-                    response_text) if response_text else {}
-
-                if status == 200 and response_data.get("errcode") == 0:
-                    SYLogger.info(f"消息发送成功: {response_data}")
-                    return response_data
-                else:
-                    SYLogger.info(
-                        f"消息发送失败 - 状态码: {status}, 响应: {response_data}")
-                    return None
-    except Exception as e:
-        SYLogger.info(f"错误：未知异常 - {str(e)}")
-        return None
-
-
-async def send_webhook(error_info: dict = None, webhook: str = None):
-    """
-    发送服务启动结果的企业微信通知
-    Args:
-        error_info: 错误信息字典（启动失败时必填），包含：error_type, error_msg, stack_trace, elapsed_time
-        webhook: 完整的企业微信WebHook URL（覆盖默认值）
-    """
-    # 获取服务名和环境（兼容配置读取失败）
-    try:
-        service_name = Config().config.get('Name', "未知服务")
-        env = Config().config.get('Nacos', {}).get('namespaceId', '未知环境')
-        webHook = Config().config.get('llm', {}).get('WebHook', '未知环境')
-    except Exception as e:
-        service_name = "未知服务"
-        env = "未知环境"
-        webHook = None
-        SYLogger.info(f"读取配置失败: {str(e)}")
-
-    start_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-
-    # 启动失败的通知内容（包含详细错误信息）
-    error_type = error_info.get("error_type", "未知错误")
-    error_msg = error_info.get("error_msg", "无错误信息")
-    stack_trace = error_info.get("stack_trace", "无堆栈信息")[:500]  # 限制长度避免超限
-    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启动监控
-    调用方式1（默认配置）：uvicorn_monitor.run("app:app", **app.state.config)
-    调用方式2（自定义webhook）：uvicorn_monitor.run("app:app", webhook="完整URL", **app.state.config)
-
-    Args:
-        *args: 传递给uvicorn.run的位置参数（如"app:app"）
-        webhook: 完整的企业微信WebHook URL（可选，覆盖默认值）
-        **kwargs: 传递给uvicorn.run的关键字参数（如app.state.config）
-    """
-    # 判断环境
-    env = Config().config.get('Nacos', {}).get('namespaceId', '未知环境')
-    if env == "prod":
-        import uvicorn
-        uvicorn.run(*args, **kwargs)
-        return
-
-    # 记录启动开始时间
-    start_time = datetime.now()
-
-    if webhook:
-        # 脱敏展示webhook（隐藏key的后半部分）
-        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}")
-
-    # 初始化错误信息
-    error_info = None
-
-    try:
-        import uvicorn
-        # 执行启动（如果启动成功，此方法会阻塞，不会执行后续except）
-        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(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.info(f"\n{'='*50}")
-        SYLogger.info(f"🚨 应用启动失败！")
-        SYLogger.info(f"失败时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-        SYLogger.info(f"错误类型: {type(e).__name__}")
-        SYLogger.info(f"错误信息: {str(e)}")
-        SYLogger.info(f"\n📝 错误堆栈（关键）:")
-        SYLogger.info(f"-"*50)
-        traceback.print_exc(file=sys.stdout)
-        SYLogger.info(f"\n⏱️  启动耗时: {elapsed:.2f} 秒")
-        SYLogger.info(f"{'='*50}\n")
-
-    finally:
-        # 运行异步通知函数，传递自定义的webhook参数
-        try:
-            asyncio.run(send_webhook(
-                error_info=error_info,
-                webhook=webhook
-            ))
-        except Exception as e:
-            SYLogger.info(f"错误：异步通知失败 - {str(e)}")
-        # 启动失败时退出程序
-        sys.exit(1)
-
-
-# 兼容旧调用方式（可选）
-run_uvicorn_with_monitor = run

sycommon/rabbitmq/rabbitmq_service_client_manager.py

@@ -1,206 +0,0 @@
-from typing import Dict
-import asyncio
-
-from sycommon.logging.kafka_log import SYLogger
-from sycommon.rabbitmq.rabbitmq_client import RabbitMQClient
-from sycommon.rabbitmq.rabbitmq_service_core import RabbitMQCoreService
-
-logger = SYLogger
-
-
-class RabbitMQClientManager(RabbitMQCoreService):
-    """
-    RabbitMQ客户端管理类 - 负责客户端的创建、获取、重连、资源清理
-    """
-    # 客户端存储
-    _clients: Dict[str, RabbitMQClient] = {}
-    _init_locks: Dict[str, asyncio.Lock] = {}
-
-    # 模式标记
-    _has_listeners: bool = False
-    _has_senders: bool = False
-
-    @classmethod
-    def set_mode_flags(cls, has_listeners: bool = False, has_senders: bool = False) -> None:
-        """设置模式标记（是否有监听器/发送器）"""
-        cls._has_listeners = has_listeners
-        cls._has_senders = has_senders
-
-    @classmethod
-    async def _clean_client_resources(cls, client: RabbitMQClient) -> None:
-        """清理客户端无效资源"""
-        try:
-            # 先停止消费
-            if client._consumer_tag:
-                await client.stop_consuming()
-            logger.debug("客户端无效资源清理完成（单通道无需归还）")
-        except Exception as e:
-            logger.warning(f"释放客户端无效资源失败: {str(e)}")
-        finally:
-            # 强制重置客户端状态
-            client._channel = None
-            client._channel_conn = None
-            client._exchange = None
-            client._queue = None
-            client._consumer_tag = None
-
-    @classmethod
-    async def _reconnect_client(cls, client_name: str, client: RabbitMQClient) -> bool:
-        """客户端重连"""
-        if cls._is_shutdown or not (cls._connection_pool and await cls._connection_pool.is_alive):
-            return False
-
-        # 重连冷却
-        await asyncio.sleep(cls.RECONNECT_INTERVAL)
-
-        try:
-            # 清理旧资源
-            await cls._clean_client_resources(client)
-
-            # 执行重连
-            await client.connect()
-
-            # 验证重连结果
-            if await client.is_connected:
-                logger.info(f"客户端 '{client_name}' 重连成功")
-                return True
-            else:
-                logger.warning(f"客户端 '{client_name}' 重连失败：资源未完全初始化")
-                return False
-        except Exception as e:
-            logger.error(f"客户端 '{client_name}' 重连失败: {str(e)}", exc_info=True)
-            return False
-
-    @classmethod
-    async def _create_client(cls, **kwargs) -> RabbitMQClient:
-        """创建客户端实例"""
-        if cls._is_shutdown:
-            raise RuntimeError("RabbitMQService已关闭，无法创建客户端")
-
-        # 等待连接池就绪
-        await cls.wait_for_pool_ready()
-
-        app_name = kwargs.get('app_name', cls._config.get(
-            "APP_NAME", "")) if cls._config else ""
-        queue_name = kwargs.get('queue_name', '')
-
-        create_if_not_exists = kwargs.get('create_if_not_exists', True)
-
-        processed_queue_name = queue_name
-        if 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}")
-            else:
-                logger.info(f"监听器队列已包含app-name: {processed_queue_name}")
-
-        logger.info(
-            f"创建客户端 - 原始队列名: {queue_name}, "
-            f"处理后队列名: {processed_queue_name}, "
-            f"是否创建队列: {create_if_not_exists}"
-        )
-
-        # 创建客户端实例
-        client = RabbitMQClient(
-            connection_pool=cls._connection_pool,
-            exchange_name=cls._config.get(
-                'exchange_name', "system.topic.exchange"),
-            exchange_type=kwargs.get('exchange_type', "topic"),
-            queue_name=None if not create_if_not_exists else processed_queue_name,
-            routing_key=kwargs.get(
-                'routing_key',
-                f"{queue_name.split('.')[0]}.#"
-            ),
-            durable=kwargs.get('durable', True),
-            auto_delete=kwargs.get('auto_delete', False),
-            auto_parse_json=kwargs.get('auto_parse_json', True),
-            create_if_not_exists=create_if_not_exists,
-            prefetch_count=kwargs.get('prefetch_count', 2),
-        )
-
-        # 连接客户端
-        await client.connect()
-
-        return client
-
-    @classmethod
-    async def get_client(
-        cls,
-        client_name: str = "default",
-        client_type: str = "sender",  # sender（发送器）/listener（监听器），默认sender
-        **kwargs
-    ) -> RabbitMQClient:
-        """
-        获取或创建RabbitMQ客户端
-        :param client_name: 客户端名称
-        :param client_type: 客户端类型 - sender(发送器)/listener(监听器)
-        :param kwargs: 其他参数
-        :return: RabbitMQClient实例
-        """
-        if cls._is_shutdown:
-            raise RuntimeError("RabbitMQService已关闭，无法获取客户端")
-
-        # 校验client_type合法性
-        if client_type not in ["sender", "listener"]:
-            raise ValueError(
-                f"client_type只能是sender/listener，当前值：{client_type}")
-
-        # 等待连接池就绪
-        await cls.wait_for_pool_ready()
-
-        # 确保锁存在
-        if client_name not in cls._init_locks:
-            cls._init_locks[client_name] = asyncio.Lock()
-
-        async with cls._init_locks[client_name]:
-            # ===== 原有“客户端已存在”的逻辑保留 =====
-            if client_name in cls._clients:
-                client = cls._clients[client_name]
-                # 核心：根据client_type重置客户端的队列创建配置
-                if client_type == "sender":
-                    client.create_if_not_exists = False
-                else:  # listener
-                    client.create_if_not_exists = True
-                    # 监听器必须有队列名，从kwargs补全
-                    if not client.queue_name and kwargs.get("queue_name"):
-                        client.queue_name = kwargs.get("queue_name")
-
-                if await client.is_connected:
-                    return client
-                else:
-                    logger.info(f"客户端 '{client_name}' 连接已断开，重新创建")
-                    await cls._clean_client_resources(client)
-
-            # ===== 核心逻辑：根据client_type统一控制队列创建 =====
-            if client_type == "sender":
-                kwargs["create_if_not_exists"] = False  # 禁用创建队列
-            else:
-                if not kwargs.get("queue_name"):
-                    raise ValueError("监听器类型必须指定queue_name参数")
-                kwargs["create_if_not_exists"] = True
-
-            client = await cls._create_client(
-                **kwargs
-            )
-
-            # 监听器额外验证队列创建结果
-            if client_type == "listener" and not client._queue:
-                raise RuntimeError(f"监听器队列 '{kwargs['queue_name']}' 创建失败")
-
-            # 存储客户端
-            cls._clients[client_name] = client
-            return client
-
-    @classmethod
-    async def shutdown_clients(cls, timeout: float = 15.0) -> None:
-        """关闭所有客户端"""
-        # 关闭所有客户端
-        for client in cls._clients.values():
-            try:
-                await client.close()
-            except Exception as e:
-                logger.error(f"关闭客户端失败: {str(e)}")
-
-        # 清理客户端状态
-        cls._clients.clear()
-        cls._init_locks.clear()

sycommon/rabbitmq/rabbitmq_service_connection_monitor.py

@@ -1,73 +0,0 @@
-import asyncio
-from typing import Optional
-from sycommon.rabbitmq.rabbitmq_service_client_manager import RabbitMQClientManager
-from sycommon.logging.kafka_log import SYLogger
-
-logger = SYLogger
-
-
-class RabbitMQConnectionMonitor(RabbitMQClientManager):
-    """
-    RabbitMQ连接监控类 - 负责连接状态监控、自动重连
-    """
-    _connection_monitor_task: Optional[asyncio.Task] = None
-
-    @classmethod
-    async def _monitor_connections(cls):
-        """连接监控任务：定期检查所有客户端连接状态"""
-        logger.info("RabbitMQ连接监控任务启动")
-        while not cls._is_shutdown:
-            try:
-                await asyncio.sleep(cls.RECONNECT_INTERVAL)
-
-                # 跳过未初始化的连接池
-                if not cls._connection_pool or not cls._connection_pool._initialized:
-                    continue
-
-                # 检查连接池本身状态
-                pool_alive = await cls._connection_pool.is_alive
-                if not pool_alive:
-                    logger.error("RabbitMQ连接池已断开，等待原生自动重连")
-                    continue
-
-                # 检查所有客户端连接
-                for client_name, client in list(cls._clients.items()):
-                    try:
-                        client_connected = await client.is_connected
-                        if not client_connected:
-                            logger.warning(
-                                f"客户端 '{client_name}' 连接异常，触发重连")
-                            asyncio.create_task(
-                                cls._reconnect_client(client_name, client))
-                    except Exception as e:
-                        logger.error(
-                            f"监控客户端 '{client_name}' 连接状态失败: {str(e)}", exc_info=True)
-
-            except Exception as e:
-                logger.error("RabbitMQ连接监控任务异常", exc_info=True)
-                await asyncio.sleep(cls.RECONNECT_INTERVAL)
-
-        logger.info("RabbitMQ连接监控任务停止")
-
-    @classmethod
-    def start_connection_monitor(cls) -> None:
-        """启动连接监控任务"""
-        if cls._connection_monitor_task and not cls._connection_monitor_task.done():
-            return
-
-        cls._connection_monitor_task = asyncio.create_task(
-            cls._monitor_connections())
-
-    @classmethod
-    async def stop_connection_monitor(cls, timeout: float = 15.0) -> None:
-        """停止连接监控任务"""
-        if cls._connection_monitor_task and not cls._connection_monitor_task.done():
-            cls._connection_monitor_task.cancel()
-            try:
-                await asyncio.wait_for(cls._connection_monitor_task, timeout=timeout)
-            except asyncio.TimeoutError:
-                logger.warning("连接监控任务关闭超时")
-            except Exception as e:
-                logger.error(f"关闭连接监控任务失败: {str(e)}")
-
-        cls._connection_monitor_task = None