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

sycommon/rabbitmq/rabbitmq_service_consumer_manager.py

@@ -1,285 +0,0 @@
-from typing import Dict, List, Callable, Coroutine, Any
-import asyncio
-from aio_pika.abc import AbstractIncomingMessage, ConsumerTag
-
-from sycommon.logging.kafka_log import SYLogger
-from sycommon.models.mqlistener_config import RabbitMQListenerConfig
-from sycommon.rabbitmq.rabbitmq_service_client_manager import RabbitMQClientManager
-from sycommon.models.mqmsg_model import MQMsgModel
-
-logger = SYLogger
-
-
-class RabbitMQConsumerManager(RabbitMQClientManager):
-    """
-    RabbitMQ消费者管理类 - 负责监听器设置、消费启动/停止、消费验证
-    """
-    # 消费者相关状态
-    _message_handlers: Dict[str, Callable[[
-        MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]]] = {}
-    _consumer_tasks: Dict[str, asyncio.Task] = {}
-    _consumer_events: Dict[str, asyncio.Event] = {}
-    _consumer_tags: Dict[str, ConsumerTag] = {}
-
-    # 配置常量
-    CONSUMER_START_TIMEOUT = 30  # 消费启动超时（秒）
-
-    @classmethod
-    async def add_listener(
-        cls,
-        queue_name: str,
-        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]], **kwargs
-    ) -> None:
-        """添加消息监听器"""
-        if cls._is_shutdown:
-            logger.warning("服务已关闭，无法添加监听器")
-            return
-
-        if queue_name in cls._message_handlers:
-            logger.info(f"监听器 '{queue_name}' 已存在，跳过重复添加")
-            return
-
-        # 创建并初始化客户端
-        await cls.get_client(
-            client_name=queue_name,
-            client_type="listener",
-            queue_name=queue_name,
-            ** kwargs
-        )
-
-        # 注册消息处理器
-        cls._message_handlers[queue_name] = handler
-        logger.info(f"监听器 '{queue_name}' 已添加")
-
-    @classmethod
-    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False, **kwargs) -> None:
-        """设置消息监听器"""
-        if cls._is_shutdown:
-            logger.warning("服务已关闭，无法设置监听器")
-            return
-
-        cls.set_mode_flags(has_listeners=True, has_senders=has_senders)
-        logger.info(f"开始设置 {len(listeners)} 个消息监听器")
-
-        for idx, listener_config in enumerate(listeners):
-            try:
-                # 转换配置
-                listener_dict = listener_config.model_dump()
-                listener_dict['create_if_not_exists'] = True
-                listener_dict['prefetch_count'] = listener_config.prefetch_count
-                queue_name = listener_dict['queue_name']
-
-                logger.info(
-                    f"设置监听器 {idx+1}/{len(listeners)}: {queue_name} (prefetch_count: {listener_config.prefetch_count})")
-
-                # 添加监听器
-                await cls.add_listener(**listener_dict)
-            except Exception as e:
-                logger.error(
-                    f"设置监听器 {idx+1} 失败: {str(e)}", exc_info=True)
-                logger.warning("继续处理其他监听器")
-
-        # 启动所有消费者
-        await cls.start_all_consumers()
-
-        # 验证消费者启动结果
-        await cls._verify_consumers_started()
-
-        logger.info(f"消息监听器设置完成")
-
-    @classmethod
-    async def _verify_consumers_started(cls, timeout: int = 30) -> None:
-        """验证消费者是否成功启动"""
-        start_time = asyncio.get_event_loop().time()
-        required_clients = list(cls._message_handlers.keys())
-        running_clients = []
-
-        while len(running_clients) < len(required_clients) and \
-                (asyncio.get_event_loop().time() - start_time) < timeout and \
-                not cls._is_shutdown:
-
-            running_clients = [
-                name for name, task in cls._consumer_tasks.items()
-                if not task.done() and name in cls._consumer_tags
-            ]
-
-            logger.info(
-                f"消费者启动验证: {len(running_clients)}/{len(required_clients)} 已启动")
-            await asyncio.sleep(1)
-
-        failed_clients = [
-            name for name in required_clients if name not in running_clients and not cls._is_shutdown]
-        if failed_clients:
-            logger.error(f"以下消费者启动失败: {', '.join(failed_clients)}")
-            for client_name in failed_clients:
-                logger.info(f"尝试重新启动消费者: {client_name}")
-                asyncio.create_task(cls.start_consumer(client_name))
-
-    @classmethod
-    async def start_all_consumers(cls) -> None:
-        """启动所有已注册的消费者"""
-        if cls._is_shutdown:
-            logger.warning("服务已关闭，无法启动消费者")
-            return
-
-        for client_name in cls._message_handlers:
-            await cls.start_consumer(client_name)
-
-    @classmethod
-    async def start_consumer(cls, client_name: str) -> None:
-        """启动指定客户端的消费者"""
-        if cls._is_shutdown:
-            logger.warning("服务已关闭，无法启动消费者")
-            return
-
-        # 检查任务状态
-        if client_name in cls._consumer_tasks:
-            existing_task = cls._consumer_tasks[client_name]
-            if not existing_task.done():
-                if existing_task.exception() is not None:
-                    logger.info(f"消费者 '{client_name}' 任务异常，重启")
-                    existing_task.cancel()
-                else:
-                    logger.info(f"消费者 '{client_name}' 已在运行中，无需重复启动")
-                    return
-            else:
-                logger.info(f"消费者 '{client_name}' 任务已完成，重新启动")
-
-        if client_name not in cls._clients:
-            raise ValueError(f"RabbitMQ客户端 '{client_name}' 未初始化")
-
-        client = cls._clients[client_name]
-        handler = cls._message_handlers.get(client_name)
-
-        if not handler:
-            logger.warning(f"未找到客户端 '{client_name}' 的处理器")
-            return
-
-        # 设置消息处理器
-        await client.set_message_handler(handler)
-
-        # 确保客户端已连接
-        start_time = asyncio.get_event_loop().time()
-        while not await client.is_connected and not cls._is_shutdown:
-            if asyncio.get_event_loop().time() - start_time > cls.CONSUMER_START_TIMEOUT:
-                raise TimeoutError(f"等待客户端 '{client_name}' 连接超时")
-
-            logger.info(f"等待客户端 '{client_name}' 连接就绪...")
-            await asyncio.sleep(1)
-        if cls._is_shutdown:
-            return
-
-        # 创建停止事件
-        stop_event = asyncio.Event()
-        cls._consumer_events[client_name] = stop_event
-
-        # 定义消费任务
-        async def consume_task():
-            try:
-                # 启动消费，带重试机制
-                max_attempts = 3
-                attempt = 0
-                consumer_tag = None
-
-                while attempt < max_attempts and not stop_event.is_set() and not cls._is_shutdown:
-                    try:
-                        # 启动消费前再次校验
-                        if not await client.is_connected:
-                            logger.info(f"消费者 '{client_name}' 连接断开，尝试重连")
-                            await client.connect()
-
-                        if not client._queue:
-                            raise Exception("队列未初始化完成")
-                        if not client._message_handler:
-                            raise Exception("消息处理器未设置")
-
-                        consumer_tag = await client.start_consuming()
-                        if consumer_tag:
-                            break
-                    except Exception as e:
-                        attempt += 1
-                        logger.warning(
-                            f"启动消费者尝试 {attempt}/{max_attempts} 失败: {str(e)}")
-                        if attempt < max_attempts:
-                            await asyncio.sleep(2)
-
-                if cls._is_shutdown:
-                    return
-
-                if not consumer_tag:
-                    raise Exception(f"经过 {max_attempts} 次尝试仍无法启动消费者")
-
-                # 记录消费者标签
-                cls._consumer_tags[client_name] = consumer_tag
-                logger.info(
-                    f"消费者 '{client_name}' 开始消费（单通道），tag: {consumer_tag}"
-                )
-
-                # 等待停止事件
-                await stop_event.wait()
-                logger.info(f"收到停止信号，消费者 '{client_name}' 准备退出")
-
-            except asyncio.CancelledError:
-                logger.info(f"消费者 '{client_name}' 被取消")
-            except Exception as e:
-                logger.error(
-                    f"消费者 '{client_name}' 错误: {str(e)}", exc_info=True)
-                # 非主动停止时尝试重启
-                if not stop_event.is_set() and not cls._is_shutdown:
-                    logger.info(f"尝试重启消费者 '{client_name}'")
-                    await asyncio.sleep(cls.RECONNECT_INTERVAL)
-                    asyncio.create_task(cls.start_consumer(client_name))
-            finally:
-                # 清理资源
-                try:
-                    await client.stop_consuming()
-                except Exception as e:
-                    logger.error(f"停止消费者 '{client_name}' 时出错: {str(e)}")
-
-                # 移除状态记录
-                if client_name in cls._consumer_tags:
-                    del cls._consumer_tags[client_name]
-                if client_name in cls._consumer_events:
-                    del cls._consumer_events[client_name]
-
-                logger.info(f"消费者 '{client_name}' 已停止")
-
-        # 创建并跟踪消费任务
-        task = asyncio.create_task(
-            consume_task(), name=f"consumer-{client_name}")
-        cls._consumer_tasks[client_name] = task
-
-        # 添加任务完成回调
-        def task_done_callback(t: asyncio.Task) -> None:
-            try:
-                if t.done():
-                    t.result()
-            except Exception as e:
-                logger.error(f"消费者任务 '{client_name}' 异常结束: {str(e)}")
-                if client_name in cls._message_handlers and not cls._is_shutdown:
-                    asyncio.create_task(cls.start_consumer(client_name))
-
-        task.add_done_callback(task_done_callback)
-        logger.info(f"消费者任务 '{client_name}' 已创建")
-
-    @classmethod
-    async def shutdown_consumers(cls, timeout: float = 15.0) -> None:
-        """关闭所有消费者"""
-        # 停止所有消费者任务
-        for client_name, task in cls._consumer_tasks.items():
-            if not task.done():
-                # 触发停止事件
-                if client_name in cls._consumer_events:
-                    cls._consumer_events[client_name].set()
-                # 取消任务
-                task.cancel()
-                try:
-                    await asyncio.wait_for(task, timeout=timeout)
-                except Exception as e:
-                    logger.error(f"关闭消费者 '{client_name}' 失败: {str(e)}")
-
-        # 清理消费者状态
-        cls._message_handlers.clear()
-        cls._consumer_tasks.clear()
-        cls._consumer_events.clear()
-        cls._consumer_tags.clear()

sycommon/rabbitmq/rabbitmq_service_core.py

@@ -1,117 +0,0 @@
-import asyncio
-from typing import Optional
-
-from sycommon.logging.kafka_log import SYLogger
-from sycommon.rabbitmq.rabbitmq_client import RabbitMQConnectionPool
-
-logger = SYLogger
-
-
-class RabbitMQCoreService:
-    """
-    RabbitMQ核心服务类 - 负责基础初始化、连接池管理、全局状态控制
-    """
-    # 全局共享状态
-    _config: Optional[dict] = None
-    _connection_pool: Optional[RabbitMQConnectionPool] = None
-    _is_shutdown: bool = False
-    _shutdown_lock = asyncio.Lock()
-
-    # 配置常量
-    RECONNECT_INTERVAL = 15  # 重连基础间隔（秒）
-    CONNECTION_POOL_TIMEOUT = 30  # 连接池初始化超时（秒）
-
-    @classmethod
-    def init_config(cls, config: dict) -> None:
-        """初始化基础配置（从Nacos加载）"""
-        from sycommon.synacos.nacos_service import NacosService
-
-        if cls._config:
-            logger.warning("RabbitMQ配置已初始化，无需重复调用")
-            return
-
-        # 从Nacos获取MQ配置
-        cls._config = NacosService(config).share_configs.get(
-            "mq.yml", {}).get('spring', {}).get('rabbitmq', {})
-        cls._config["APP_NAME"] = config.get("Name", "")
-
-        # 打印关键配置信息
-        logger.info(
-            f"RabbitMQ服务初始化 - 集群节点: {cls._config.get('host')}, "
-            f"端口: {cls._config.get('port')}, "
-            f"虚拟主机: {cls._config.get('virtual-host')}, "
-            f"应用名: {cls._config.get('APP_NAME')}, "
-            f"心跳: {cls._config.get('heartbeat', 30)}s"
-        )
-        cls._is_shutdown = False
-
-    @classmethod
-    async def init_connection_pool(cls) -> None:
-        """初始化单通道连接池（带重试机制）"""
-        if cls._connection_pool or not cls._config or cls._is_shutdown:
-            return
-
-        try:
-            # 解析集群节点
-            hosts_str = cls._config.get('host', "")
-            hosts_list = [host.strip()
-                          for host in hosts_str.split(',') if host.strip()]
-            if not hosts_list:
-                raise ValueError("RabbitMQ集群配置为空，请检查host参数")
-
-            global_prefetch_count = cls._config.get('prefetch_count', 2)
-
-            # 创建单通道连接池
-            cls._connection_pool = RabbitMQConnectionPool(
-                hosts=hosts_list,
-                port=cls._config.get('port', 5672),
-                username=cls._config.get('username', ""),
-                password=cls._config.get('password', ""),
-                virtualhost=cls._config.get('virtual-host', "/"),
-                app_name=cls._config.get("APP_NAME", ""),
-                prefetch_count=global_prefetch_count,
-                heartbeat=cls._config.get('heartbeat', 15),
-                connection_timeout=cls._config.get('connection_timeout', 15),
-                reconnect_interval=cls._config.get('reconnect_interval', 5),
-            )
-
-            # 初始化连接池
-            await asyncio.wait_for(cls._connection_pool.init_pools(), timeout=cls.CONNECTION_POOL_TIMEOUT)
-            logger.info("RabbitMQ单通道连接池初始化成功")
-
-        except Exception as e:
-            logger.error(f"RabbitMQ连接池初始化失败: {str(e)}", exc_info=True)
-            # 连接池初始化失败时重试（未关闭状态下）
-            if not cls._is_shutdown:
-                await asyncio.sleep(cls.RECONNECT_INTERVAL)
-                asyncio.create_task(cls.init_connection_pool())
-
-    @classmethod
-    async def wait_for_pool_ready(cls) -> None:
-        """等待连接池就绪（带超时）"""
-        if not cls._config:
-            raise ValueError("RabbitMQ配置尚未初始化，请先调用init_config方法")
-
-        start_time = asyncio.get_event_loop().time()
-        while not (cls._connection_pool and cls._connection_pool._initialized) and not cls._is_shutdown:
-            if asyncio.get_event_loop().time() - start_time > cls.CONNECTION_POOL_TIMEOUT:
-                raise TimeoutError("等待连接池初始化超时")
-            await asyncio.sleep(1)
-
-        if cls._is_shutdown:
-            raise RuntimeError("服务关闭中，取消等待连接池")
-
-    @classmethod
-    async def shutdown_core_resources(cls, timeout: float = 15.0) -> None:
-        """关闭核心资源（连接池）"""
-        # 关闭连接池
-        if cls._connection_pool and cls._connection_pool._initialized:
-            try:
-                await cls._connection_pool.close()
-                logger.info("RabbitMQ单通道连接池已关闭")
-            except Exception as e:
-                logger.error(f"关闭连接池失败: {str(e)}")
-
-        # 清理核心状态
-        cls._config = None
-        cls._connection_pool = None

sycommon/rabbitmq/rabbitmq_service_producer_manager.py

@@ -1,238 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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)}")