sycommon-python-lib 0.1.55b0__py3-none-any.whl → 0.1.56__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_service_producer_manager.py

@@ -0,0 +1,238 @@
+from typing import List, Optional, Union, Dict, Any
+import asyncio
+import json
+import time
+from pydantic import BaseModel
+
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.models.mqsend_config import RabbitMQSendConfig
+from sycommon.config.Config import Config
+from sycommon.models.sso_user import SsoUser
+from sycommon.models.mqmsg_model import MQMsgModel
+from sycommon.rabbitmq.rabbitmq_client import RabbitMQClient
+from sycommon.rabbitmq.rabbitmq_service_client_manager import RabbitMQClientManager
+
+logger = SYLogger
+
+
+class RabbitMQProducerManager(RabbitMQClientManager):
+    """
+    RabbitMQ生产者管理类 - 负责发送器设置、消息发送
+    """
+    # 发送器相关状态
+    _sender_client_names: List[str] = []
+
+    @classmethod
+    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False, **kwargs) -> None:
+        """设置消息发送器（适配client_type参数，确保发送器不创建队列）"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法设置发送器")
+            return
+
+        cls.set_mode_flags(has_listeners=has_listeners, has_senders=True)
+        logger.info(f"开始设置 {len(senders)} 个消息发送器，纯发送器模式: {not has_listeners}")
+
+        for idx, sender_config in enumerate(senders):
+            try:
+                if not sender_config.queue_name:
+                    raise ValueError(f"发送器配置第{idx+1}项缺少queue_name")
+
+                prefetch_count = sender_config.prefetch_count
+                queue_name = sender_config.queue_name
+                app_name = cls._config.get(
+                    "APP_NAME", "") if cls._config else ""
+
+                # 处理发送器客户端名称（非队列名）
+                normalized_name = queue_name
+                if app_name and normalized_name.endswith(f".{app_name}"):
+                    normalized_name = normalized_name[:-len(f".{app_name}")]
+                    logger.info(f"发送器客户端名称移除app-name后缀: {normalized_name}")
+
+                # 检查是否已初始化
+                if normalized_name in cls._sender_client_names:
+                    logger.info(f"发送客户端 '{normalized_name}' 已存在，跳过")
+                    continue
+
+                # ===== 处理已有客户端重连 =====
+                if normalized_name in cls._clients:
+                    client = cls._clients[normalized_name]
+                    if not await client.is_connected:
+                        client.queue_name = normalized_name
+                        client.create_if_not_exists = False
+                        await client.connect()
+                else:
+                    client = await cls.get_client(
+                        client_name=normalized_name,
+                        client_type="sender",
+                        exchange_type=sender_config.exchange_type,
+                        durable=sender_config.durable,
+                        auto_delete=sender_config.auto_delete,
+                        auto_parse_json=sender_config.auto_parse_json,
+                        queue_name=queue_name,
+                        create_if_not_exists=False,
+                        prefetch_count=prefetch_count,
+                        **kwargs
+                    )
+
+                # 记录客户端
+                if normalized_name not in cls._clients:
+                    cls._clients[normalized_name] = client
+                    logger.info(f"发送客户端 '{normalized_name}' 已添加")
+
+                if normalized_name not in cls._sender_client_names:
+                    cls._sender_client_names.append(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)} 个发送器，纯发送器模式: {not has_listeners}")
+
+    @classmethod
+    async def get_sender(cls, queue_name: str) -> Optional[RabbitMQClient]:
+        """获取发送客户端"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法获取发送器")
+            return None
+
+        if not queue_name:
+            logger.warning("发送器名称不能为空")
+            return None
+
+        # 检查是否在已注册的发送器中
+        if queue_name in cls._sender_client_names and queue_name in cls._clients:
+            client = cls._clients[queue_name]
+            if await client.is_connected:
+                return client
+            else:
+                logger.info(f"发送器 '{queue_name}' 连接已断开，尝试重连")
+                try:
+                    client.create_if_not_exists = False
+                    await client.connect()
+                    if await client.is_connected:
+                        return client
+                except Exception as e:
+                    logger.error(f"发送器 '{queue_name}' 重连失败: {str(e)}")
+            return None
+
+        # 检查是否带有app-name后缀
+        app_name = cls._config.get("APP_NAME", "") if cls._config else ""
+        if app_name:
+            suffixed_name = f"{queue_name}.{app_name}"
+            if suffixed_name in cls._sender_client_names and suffixed_name in cls._clients:
+                client = cls._clients[suffixed_name]
+                if await client.is_connected:
+                    return client
+                else:
+                    logger.info(f"发送器 '{suffixed_name}' 连接已断开，尝试重连")
+                    try:
+                        client.create_if_not_exists = False
+                        await client.connect()
+                        if await client.is_connected:
+                            return client
+                    except Exception as e:
+                        logger.error(f"发送器 '{suffixed_name}' 重连失败: {str(e)}")
+
+        logger.info(f"未找到可用的发送器 '{queue_name}'")
+        return None
+
+    @classmethod
+    async def send_message(
+        cls,
+        data: Union[BaseModel, str, Dict[str, Any], None],
+        queue_name: str, **kwargs
+    ) -> None:
+        """发送消息到指定队列"""
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法发送消息")
+
+        # 获取发送客户端
+        sender = await cls.get_sender(queue_name)
+        if not sender:
+            error_msg = f"未找到可用的RabbitMQ发送器 (queue_name: {queue_name})"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        # 确保连接有效
+        if not await sender.is_connected:
+            logger.info(f"发送器 '{queue_name}' 连接已关闭，尝试重新连接")
+            max_retry = 3
+            retry_count = 0
+            last_exception = None
+
+            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(
+                            f"发送器 '{queue_name}' 第 {retry_count + 1} 次重连成功")
+                        break
+                except Exception as e:
+                    last_exception = e
+                    retry_count += 1
+                    logger.warning(
+                        f"发送器 '{queue_name}' 第 {retry_count} 次重连失败: {str(e)}")
+                    await asyncio.sleep(cls.RECONNECT_INTERVAL)
+
+            if retry_count >= max_retry and not await sender.is_connected:
+                error_msg = f"发送器 '{queue_name}' 经过 {max_retry} 次重连仍失败"
+                logger.error(f"{error_msg}: {str(last_exception)}")
+                raise Exception(error_msg) from last_exception
+
+        try:
+            # 处理消息数据
+            msg_content = ""
+            if isinstance(data, str):
+                msg_content = data
+            elif isinstance(data, BaseModel):
+                msg_content = data.model_dump_json()
+            elif isinstance(data, dict):
+                msg_content = json.dumps(data, ensure_ascii=False)
+
+            # 创建标准消息模型
+            mq_message = MQMsgModel(
+                topicCode=queue_name.split('.')[0] if queue_name else "",
+                msg=msg_content,
+                correlationDataId=kwargs.get(
+                    'correlationDataId', logger.get_trace_id()),
+                groupId=kwargs.get('groupId', ''),
+                dataKey=kwargs.get('dataKey', ""),
+                manualFlag=kwargs.get('manualFlag', False),
+                traceId=logger.get_trace_id()
+            )
+
+            # 构建消息头
+            namespaceId = Config().config.get('Nacos', {}).get('namespaceId', '')
+            tenant_id = "T000002" if namespaceId == "prod" or namespaceId == "wsuat1" else "T000003"
+            mq_header = {
+                "context": SsoUser(
+                    tenant_id=tenant_id,
+                    customer_id="SYSTEM",
+                    user_id="SYSTEM",
+                    user_name="SYSTEM",
+                    request_path="/",
+                    req_type="SYSTEM",
+                    trace_id=logger.get_trace_id(),
+                ).model_dump_json(),
+                "tenant_id": logger.get_trace_id(),
+                "createTime": str(int(time.time() * 1000)),
+            }
+
+            # 发送消息
+            await sender.publish(
+                message_body=mq_message.model_dump_json(),
+                headers=mq_header,
+                content_type="application/json"
+            )
+            logger.info(f"消息发送成功 (队列: {queue_name})")
+        except Exception as e:
+            logger.error(f"消息发送失败: {str(e)}", exc_info=True)
+            raise
+
+    @classmethod
+    def clear_senders(cls) -> None:
+        """清理发送器状态"""
+        cls._sender_client_names.clear()

sycommon/sentry/sy_sentry.py

@@ -0,0 +1,35 @@
+import sentry_sdk
+from datetime import datetime
+from sycommon.config.Config import Config
+from sycommon.logging.kafka_log import SYLogger
+from sentry_sdk.integrations.fastapi import FastApiIntegration
+# from sentry_sdk.integrations.logging import LoggingIntegration
+
+
+def sy_sentry_init():
+    config = Config().config
+    server_name = config.get('Name', '')
+    environment = config.get('Nacos', {}).get('namespaceId', '')
+    sentry_configs = config.get('SentryConfig', [])
+    target_config = next(
+        (item for item in sentry_configs if item.get('name') == server_name), None)
+    if target_config:
+        target_dsn = target_config.get('dsn')
+        target_enable = target_config.get('enable')
+        current_version = datetime.now().strftime("%Y-%m-%d %H:%M:%S-version")
+        if target_config and target_dsn and target_enable:
+            try:
+                sentry_sdk.init(
+                    dsn=target_dsn,
+                    traces_sample_rate=1.0,
+                    server_name=server_name,
+                    environment=environment,
+                    release=current_version,
+                    integrations=[
+                        FastApiIntegration(),
+                        # LoggingIntegration(level=logging.INFO,
+                        #                    event_level=logging.ERROR)
+                    ],
+                )
+            except Exception as e:
+                SYLogger.error(f"Sentry初始化失败: {str(e)}")

sycommon/services.py

@@ -7,31 +7,37 @@ from fastapi import FastAPI, applications
 from pydantic import BaseModel
 from typing import Any, Callable, Dict, List, Tuple, Union, Optional, AsyncGenerator
 from sycommon.config.Config import SingletonMeta
+from sycommon.logging.logger_levels import setup_logger_levels
 from sycommon.models.mqlistener_config import RabbitMQListenerConfig
 from sycommon.models.mqsend_config import RabbitMQSendConfig
 from sycommon.rabbitmq.rabbitmq_service import RabbitMQService
 from sycommon.tools.docs import custom_redoc_html, custom_swagger_ui_html
+from sycommon.sentry.sy_sentry import sy_sentry_init
 
 
 class Services(metaclass=SingletonMeta):
     _loop: Optional[asyncio.AbstractEventLoop] = None
     _config: Optional[dict] = None
     _initialized: bool = False
-    _registered_senders: List[str] = []
     _instance: Optional['Services'] = None
     _app: Optional[FastAPI] = None
     _user_lifespan: Optional[Callable] = None
     _shutdown_lock: asyncio.Lock = asyncio.Lock()
 
     def __init__(self, config: dict, app: FastAPI):
+        super().__init__()
         if not Services._config:
             Services._config = config
         Services._instance = self
         Services._app = app
+
+        # 在实例初始化时定义变量，防止类变量污染
+        self._pending_async_db_setup: List[Tuple[Callable, str]] = []
+
         self._init_event_loop()
 
     def _init_event_loop(self):
-        """初始化事件循环，确保全局只有一个循环实例"""
+        """初始化事件循环"""
         if not Services._loop:
             try:
                 Services._loop = asyncio.get_running_loop()
@@ -48,25 +54,31 @@ class Services(metaclass=SingletonMeta):
         nacos_service: Optional[Callable[[dict], None]] = None,
         logging_service: Optional[Callable[[dict], None]] = None,
         database_service: Optional[Union[
-            Tuple[Callable[[dict, str], None], str],
-            List[Tuple[Callable[[dict, str], None], str]]
+            Tuple[Callable, str],
+            List[Tuple[Callable, str]]
         ]] = None,
         rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
         rabbitmq_senders: Optional[List[RabbitMQSendConfig]] = None
     ) -> FastAPI:
         load_dotenv()
-        # 保存应用实例和配置
+        setup_logger_levels()
         cls._app = app
         cls._config = config
+        # 保存原始的用户 lifespan
         cls._user_lifespan = app.router.lifespan_context
-        # 设置文档
+
         applications.get_swagger_ui_html = custom_swagger_ui_html
         applications.get_redoc_html = custom_redoc_html
-        # 设置app.state host, port
+
         if not cls._config:
-            config = yaml.safe_load(open('app.yaml', 'r', encoding='utf-8'))
-            cls._config = config
-        # 使用config
+            try:
+                with open('app.yaml', 'r', encoding='utf-8') as f:
+                    config = yaml.safe_load(f)
+                cls._config = config
+            except FileNotFoundError:
+                logging.warning("未找到 app.yaml，将使用空配置启动")
+                cls._config = {}
+
         app.state.config = {
             "host": cls._config.get('Host', '0.0.0.0'),
             "port": cls._config.get('Port', 8080),
@@ -74,74 +86,96 @@ class Services(metaclass=SingletonMeta):
             "h11_max_incomplete_event_size": cls._config.get('H11MaxIncompleteEventSize', 1024 * 1024 * 10)
         }
 
-        # 立即配置非异步服务（在应用启动前）
         if middleware:
-            middleware(app, config)
+            middleware(app, cls._config)
 
         if nacos_service:
-            nacos_service(config)
+            nacos_service(cls._config)
 
         if logging_service:
-            logging_service(config)
+            logging_service(cls._config)
 
-        if database_service:
-            cls._setup_database_static(database_service, config)
+        sy_sentry_init()
 
-        # 创建组合生命周期管理器
         @asynccontextmanager
-        async def combined_lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
-            # 1. 执行Services自身的初始化
-            instance = cls(config, app)
-
-            # 明确判断是否有有效的监听器/发送器配置
-            has_valid_listeners = bool(
-                rabbitmq_listeners and len(rabbitmq_listeners) > 0)
-            has_valid_senders = bool(
-                rabbitmq_senders and len(rabbitmq_senders) > 0)
+        async def combined_lifespan(app_instance: FastAPI) -> AsyncGenerator[None, None]:
+            # 获取 Services 实例
+            instance = cls(config, app_instance)
 
             try:
-                # 只有存在监听器或发送器时才初始化RabbitMQService
-                if has_valid_listeners or has_valid_senders:
-                    await instance._setup_mq_async(
-                        rabbitmq_listeners=rabbitmq_listeners if has_valid_listeners else None,
-                        rabbitmq_senders=rabbitmq_senders if has_valid_senders else None,
-                        has_listeners=has_valid_listeners,
-                        has_senders=has_valid_senders
-                    )
-                cls._initialized = True
-                logging.info("Services初始化完成")
-            except Exception as e:
-                logging.error(f"Services初始化失败: {str(e)}", exc_info=True)
-                raise
+                # 1. 处理数据库服务
+                if database_service:
+                    instance._pending_async_db_setup = []
+
+                    items = [database_service] if isinstance(
+                        database_service, tuple) else database_service
+                    for item in items:
+                        db_setup_func, db_name = item
+                        if asyncio.iscoroutinefunction(db_setup_func):
+                            logging.info(f"注册异步数据库服务: {db_name}")
+                            instance._pending_async_db_setup.append(item)
+                        else:
+                            logging.info(f"执行同步数据库服务: {db_name}")
+                            try:
+                                db_setup_func(config, db_name)
+                            except Exception as e:
+                                logging.error(
+                                    f"同步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                                raise
+
+                # 2. 执行挂起的异步数据库初始化
+                if instance._pending_async_db_setup:
+                    logging.info("开始执行异步数据库初始化...")
+                    for db_setup_func, db_name in instance._pending_async_db_setup:
+                        try:
+                            await db_setup_func(config, db_name)
+                            logging.info(f"异步数据库服务 {db_name} 初始化成功")
+                        except Exception as e:
+                            logging.error(
+                                f"异步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                            raise
+
+                # 3. 初始化 MQ
+                has_valid_listeners = bool(
+                    rabbitmq_listeners and len(rabbitmq_listeners) > 0)
+                has_valid_senders = bool(
+                    rabbitmq_senders and len(rabbitmq_senders) > 0)
+
+                try:
+                    if has_valid_listeners or has_valid_senders:
+                        await instance._setup_mq_async(
+                            rabbitmq_listeners=rabbitmq_listeners if has_valid_listeners else None,
+                            rabbitmq_senders=rabbitmq_senders if has_valid_senders else None,
+                            has_listeners=has_valid_listeners,
+                            has_senders=has_valid_senders
+                        )
+                    cls._initialized = True
+                    logging.info("Services初始化完成")
+                except Exception as e:
+                    logging.error(f"MQ初始化失败: {str(e)}", exc_info=True)
+                    raise
 
-            app.state.services = instance
+                app_instance.state.services = instance
 
-            # 2. 执行用户定义的生命周期
-            if cls._user_lifespan:
-                async with cls._user_lifespan(app):
-                    yield  # 应用运行阶段
-            else:
-                yield  # 没有用户生命周期时直接 yield
+                # 4. 执行用户定义的生命周期
+                if cls._user_lifespan:
+                    async with cls._user_lifespan(app_instance):
+                        yield
+                else:
+                    yield
 
-            # 3. 执行Services的关闭逻辑
-            await cls.shutdown()
-            logging.info("Services已关闭")
+            except Exception:
+                # 如果启动过程中发生任何异常，确保进入 shutdown
+                logging.error("启动阶段发生异常，准备执行清理...")
+                raise
+            finally:
+                # 无论成功或失败，都会执行关闭逻辑
+                await cls.shutdown()
+                logging.info("Services已关闭")
 
-        # 设置组合生命周期
         app.router.lifespan_context = combined_lifespan
-
         return app
 
-    @staticmethod
-    def _setup_database_static(database_service, config):
-        """静态方法：设置数据库服务"""
-        if isinstance(database_service, tuple):
-            db_setup, db_name = database_service
-            db_setup(config, db_name)
-        elif isinstance(database_service, list):
-            for db_setup, db_name in database_service:
-                db_setup(config, db_name)
-
     async def _setup_mq_async(
         self,
         rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
@@ -149,27 +183,30 @@ class Services(metaclass=SingletonMeta):
         has_listeners: bool = False,
         has_senders: bool = False,
     ):
-        """异步设置MQ相关服务（适配单通道RabbitMQService）"""
-        # ========== 只有需要使用MQ时才初始化 ==========
+        """异步设置MQ相关服务"""
         if not (has_listeners or has_senders):
             logging.info("无RabbitMQ监听器/发送器配置，跳过RabbitMQService初始化")
             return
 
-        # 仅当有监听器或发送器时，才执行RabbitMQService初始化
         RabbitMQService.init(self._config, has_listeners, has_senders)
 
-        # 优化：等待连接池“存在且初始化完成”（避免提前执行后续逻辑）
         start_time = asyncio.get_event_loop().time()
-        while not (RabbitMQService._connection_pool and RabbitMQService._connection_pool._initialized) and not RabbitMQService._is_shutdown:
-            if asyncio.get_event_loop().time() - start_time > 30:
-                raise TimeoutError("RabbitMQ连接池初始化超时（30秒）")
-            logging.info("等待RabbitMQ连接池初始化...")
+        timeout = 30  # 超时时间秒
+
+        # 等待连接池初始化
+        while not (RabbitMQService._connection_pool and RabbitMQService._connection_pool._initialized) \
+                and not RabbitMQService._is_shutdown:
+            if asyncio.get_event_loop().time() - start_time > timeout:
+                logging.error("RabbitMQ连接池初始化超时")
+                raise TimeoutError(f"RabbitMQ连接池初始化超时（{timeout}秒）")
+
+            logging.debug("等待RabbitMQ连接池初始化...")
             await asyncio.sleep(0.5)
 
-        # ========== 保留原有严格的发送器/监听器初始化判断 ==========
-        # 只有配置了发送器才执行发送器初始化
+        if RabbitMQService._is_shutdown:
+            raise RuntimeError("RabbitMQService 在初始化期间被关闭")
+
         if has_senders and rabbitmq_senders:
-            # 判断是否有监听器，如果有遍历监听器列表，队列名一样将prefetch_count属性设置到发送器对象中
             if has_listeners and rabbitmq_listeners:
                 for sender in rabbitmq_senders:
                     for listener in rabbitmq_listeners:
@@ -177,31 +214,22 @@ class Services(metaclass=SingletonMeta):
                             sender.prefetch_count = listener.prefetch_count
             await self._setup_senders_async(rabbitmq_senders, has_listeners)
 
-        # 只有配置了监听器才执行监听器初始化
         if has_listeners and rabbitmq_listeners:
             await self._setup_listeners_async(rabbitmq_listeners, has_senders)
 
-        # 验证初始化结果
         if has_listeners:
-            # 异步获取客户端数量（适配新的RabbitMQService）
             listener_count = len(RabbitMQService._consumer_tasks)
             logging.info(f"监听器初始化完成，共启动 {listener_count} 个消费者")
             if listener_count == 0:
                 logging.warning("未成功初始化任何监听器，请检查配置或MQ服务状态")
 
     async def _setup_senders_async(self, rabbitmq_senders, has_listeners: bool):
-        """设置发送器（适配新的RabbitMQService异步方法）"""
-        Services._registered_senders = [
-            sender.queue_name for sender in rabbitmq_senders]
-
-        # 将是否有监听器的信息传递给RabbitMQService（异步调用）
+        """设置发送器"""
         await RabbitMQService.setup_senders(rabbitmq_senders, has_listeners)
-        # 更新已注册的发送器（从RabbitMQService获取实际注册的名称）
-        Services._registered_senders = RabbitMQService._sender_client_names
-        logging.info(f"已注册的RabbitMQ发送器: {Services._registered_senders}")
+        logging.info(f"RabbitMQ发送器注册完成")
 
     async def _setup_listeners_async(self, rabbitmq_listeners, has_senders: bool):
-        """设置监听器（适配新的RabbitMQService异步方法）"""
+        """设置监听器"""
         await RabbitMQService.setup_listeners(rabbitmq_listeners, has_senders)
 
     @classmethod
@@ -212,7 +240,7 @@ class Services(metaclass=SingletonMeta):
         max_retries: int = 3,
         retry_delay: float = 1.0, **kwargs
     ) -> None:
-        """发送消息，添加重试机制（适配单通道RabbitMQService）"""
+        """发送消息"""
         if not cls._initialized or not cls._loop:
             logging.error("Services not properly initialized!")
             raise ValueError("服务未正确初始化")
@@ -223,18 +251,13 @@ class Services(metaclass=SingletonMeta):
 
         for attempt in range(max_retries):
             try:
-                # 验证发送器是否注册
-                if queue_name not in cls._registered_senders:
-                    cls._registered_senders = RabbitMQService._sender_client_names
-                    if queue_name not in cls._registered_senders:
-                        raise ValueError(f"发送器 {queue_name} 未注册")
-
-                # 获取发送器（适配新的异步get_sender方法）
+                # 依赖 RabbitMQService 的内部状态
                 sender = await RabbitMQService.get_sender(queue_name)
+
                 if not sender:
-                    raise ValueError(f"发送器 '{queue_name}' 不存在或连接无效")
+                    raise ValueError(
+                        f"发送器 '{queue_name}' 不存在或未在 RabbitMQService 中注册")
 
-                # 发送消息（调用RabbitMQService的异步send_message）
                 await RabbitMQService.send_message(data, queue_name, **kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
                 return
@@ -244,25 +267,31 @@ class Services(metaclass=SingletonMeta):
                     logging.error(
                         f"消息发送失败（已尝试 {max_retries} 次）: {str(e)}", exc_info=True)
                     raise
-
                 logging.warning(
-                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，"
-                    f"{retry_delay}秒后重试..."
-                )
+                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，{retry_delay}秒后重试...")
                 await asyncio.sleep(retry_delay)
 
     @classmethod
     async def shutdown(cls):
-        """关闭所有服务（适配单通道RabbitMQService关闭逻辑）"""
+        """关闭所有服务"""
         async with cls._shutdown_lock:
             if RabbitMQService._is_shutdown:
                 logging.info("RabbitMQService已关闭，无需重复操作")
                 return
 
-            # 关闭RabbitMQ服务（异步调用，内部会关闭所有客户端+消费任务）
-            await RabbitMQService.shutdown()
+            try:
+                await RabbitMQService.shutdown()
+            except Exception as e:
+                logging.error(f"关闭 RabbitMQService 时发生异常: {e}", exc_info=True)
 
-            # 清理全局状态
             cls._initialized = False
-            cls._registered_senders.clear()
+
+            # 清理实例数据
+            if cls._instance:
+                cls._instance._pending_async_db_setup.clear()
+
+            # 这对于热重载（reload）时防止旧实例内存泄漏至关重要
+            if cls._app:
+                cls._app.state.services = None
+
             logging.info("所有服务已关闭")