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

sycommon/logging/kafka_log.py

@@ -15,7 +15,7 @@ from kafka import KafkaProducer
 from loguru import logger
 import loguru
 from sycommon.config.Config import Config, SingletonMeta
-from sycommon.middleware.context import current_trace_id, current_headers
+from sycommon.middleware.context import current_trace_id
 from sycommon.tools.snowflake import Snowflake
 
 # 配置Loguru的颜色方案
@@ -441,18 +441,6 @@ class SYLogger:
         """重置当前的 trace_id"""
         current_trace_id.reset(token)
 
-    @staticmethod
-    def get_headers():
-        return current_headers.get()
-
-    @staticmethod
-    def set_headers(headers: list[tuple[str, str]]):
-        return current_headers.set(headers)
-
-    @staticmethod
-    def reset_headers(token):
-        current_headers.reset(token)
-
     @staticmethod
     def _get_execution_context() -> str:
         """获取当前执行上下文的线程或协程信息，返回格式化字符串"""

sycommon/middleware/context.py

@@ -1,5 +1,3 @@
 import contextvars
 
 current_trace_id = contextvars.ContextVar("trace_id", default=None)
-
-current_headers = contextvars.ContextVar("headers", default=None)

sycommon/middleware/traceid.py

@@ -3,53 +3,33 @@ import re
 from typing import Dict, Any
 from fastapi import Request, Response
 from sycommon.logging.kafka_log import SYLogger
-from sycommon.tools.merge_headers import merge_headers
 from sycommon.tools.snowflake import Snowflake
 
 
 def setup_trace_id_handler(app):
     @app.middleware("http")
     async def trace_id_and_log_middleware(request: Request, call_next):
-        # ========== 1. 请求阶段：确保获取/生成 x-traceId-header ==========
-        # 优先从请求头读取（兼容任意大小写）
-        trace_id = request.headers.get(
-            "x-traceId-header") or request.headers.get("x-traceid-header")
-        # 无则生成雪花ID
+        # 生成或获取 traceId
+        trace_id = request.headers.get("x-traceId-header")
         if not trace_id:
             trace_id = Snowflake.id
 
-        # 设置 trace_id 到日志上下文
+        # 设置 trace_id 上下文
         token = SYLogger.set_trace_id(trace_id)
-        header_token = SYLogger.set_headers(request.headers.raw)
 
         # 获取请求参数
         query_params = dict(request.query_params)
         request_body: Dict[str, Any] = {}
         files_info: Dict[str, str] = {}
 
-        json_content_types = [
-            "application/json",
-            "text/plain;charset=utf-8",
-            "text/plain"
-        ]
+        # 检测请求内容类型
         content_type = request.headers.get("content-type", "").lower()
-        is_json_content = any(ct in content_type for ct in json_content_types)
 
-        if is_json_content and request.method in ["POST", "PUT", "PATCH"]:
+        if "application/json" in content_type and request.method in ["POST", "PUT", "PATCH"]:
             try:
-                # 兼容纯文本格式的 JSON（先读文本再解析）
-                if "text/plain" in content_type:
-                    raw_text = await request.text(encoding="utf-8")
-                    request_body = json.loads(raw_text)
-                else:
-                    # application/json 直接解析
-                    request_body = await request.json()
+                request_body = await request.json()
             except Exception as e:
-                try:
-                    request_body = await request.json()
-                except Exception as e:
-                    # 精准捕获 JSON 解析错误（而非泛 Exception）
-                    request_body = {"error": f"JSON parse failed: {str(e)}"}
+                request_body = {"error": f"Failed to parse JSON: {str(e)}"}
 
         elif "multipart/form-data" in content_type and request.method in ["POST", "PUT"]:
             try:
@@ -82,9 +62,8 @@ def setup_trace_id_handler(app):
                 request_body = {
                     "error": f"Failed to process form data: {str(e)}"}
 
-        # 构建请求日志（包含 traceId）
+        # 构建请求日志信息
         request_message = {
-            "traceId": trace_id,  # 请求日志中加入 traceId
             "method": request.method,
             "url": str(request.url),
             "query_params": query_params,
@@ -98,159 +77,70 @@ def setup_trace_id_handler(app):
             # 处理请求
             response = await call_next(request)
 
-            # 获取响应Content-Type（统一小写）
-            content_type = response.headers.get("content-type", "").lower()
+            content_type = response.headers.get("Content-Type", "")
 
-            # ========== 2. SSE 响应：仅设置 x-traceId-header，不修改其他头 ==========
+            # 处理 SSE 响应
             if "text/event-stream" in content_type:
-                try:
-                    # 强制写入 x-traceId-header 到响应头
-                    response.headers["x-traceId-header"] = trace_id
-                    # 确保前端能读取（仅补充暴露头，不覆盖原有值）
-                    expose_headers = response.headers.get(
-                        "access-control-expose-headers", "")
-                    if expose_headers:
-                        if "x-traceId-header" not in expose_headers.lower():
-                            response.headers[
-                                "access-control-expose-headers"] = f"{expose_headers}, x-traceId-header"
-                    else:
-                        response.headers["access-control-expose-headers"] = "x-traceId-header"
-                    # SSE 必须移除 Content-Length（仅这一个额外操作）
-                    headers_lower = {
-                        k.lower(): k for k in response.headers.keys()}
-                    if "content-length" in headers_lower:
-                        del response.headers[headers_lower["content-length"]]
-                except AttributeError:
-                    # 流式响应头只读：初始化时仅加入 traceId 和必要暴露头
-                    new_headers = dict(response.headers) if hasattr(
-                        response.headers, 'items') else {}
-                    new_headers["x-traceId-header"] = trace_id  # 强制加入
-                    # 保留原有暴露头，补充 traceId
-                    if "access-control-expose-headers" in new_headers:
-                        if "x-traceId-header" not in new_headers["access-control-expose-headers"].lower():
-                            new_headers["access-control-expose-headers"] += ", x-traceId-header"
-                    else:
-                        new_headers["access-control-expose-headers"] = "x-traceId-header"
-                    # 移除 Content-Length
-                    new_headers.pop("content-length", None)
-                    response.init_headers(new_headers)
+                # 流式响应不能有Content-Length，移除它
+                if "Content-Length" in response.headers:
+                    del response.headers["Content-Length"]
+                response.headers["x-traceId-header"] = trace_id
                 return response
 
-            # ========== 3. 非 SSE 响应：强制写入 x-traceId-header，保留 CORS ==========
-            # 备份 CORS 头（防止丢失）
-            cors_headers = {}
-            cors_header_keys = [
-                "access-control-allow-origin",
-                "access-control-allow-methods",
-                "access-control-allow-headers",
-                "access-control-expose-headers",
-                "access-control-allow-credentials",
-                "access-control-max-age"
-            ]
-            for key in cors_header_keys:
-                for k in response.headers.keys():
-                    if k.lower() == key:
-                        cors_headers[key] = response.headers[k]
-                        break
-
-            # 合并 headers（非 SSE 场景）
-            merged_headers = merge_headers(
-                source_headers=request.headers,
-                target_headers=response.headers,
-                keep_keys=None,
-                delete_keys={'content-length', 'accept', 'content-type'}
-            )
-
-            # 强制加入 x-traceId-header（优先级最高）
-            merged_headers["x-traceId-header"] = trace_id
-            # 恢复 CORS 头 + 补充 traceId 到暴露头
-            merged_headers.update(cors_headers)
-            expose_headers = merged_headers.get(
-                "access-control-expose-headers", "")
-            if expose_headers:
-                if "x-traceId-header" not in expose_headers.lower():
-                    merged_headers["access-control-expose-headers"] = f"{expose_headers}, x-traceId-header"
-            else:
-                merged_headers["access-control-expose-headers"] = "x-traceId-header"
-
-            # 更新响应头
-            if hasattr(response.headers, 'clear'):
-                response.headers.clear()
-                for k, v in merged_headers.items():
-                    response.headers[k] = v
-            elif hasattr(response, "init_headers"):
-                response.init_headers(merged_headers)
-            else:
-                for k, v in merged_headers.items():
-                    try:
-                        response.headers[k] = v
-                    except (AttributeError, KeyError):
-                        pass
-
-            # 处理普通响应体（JSON 加入 traceId）
+            # 处理普通响应
             response_body = b""
             try:
+                # 收集所有响应块
                 async for chunk in response.body_iterator:
                     response_body += chunk
 
-                # 获取 Content-Disposition（统一小写）
                 content_disposition = response.headers.get(
-                    "content-disposition", "").lower()
+                    "Content-Disposition", "")
 
-                # JSON 响应体加入 traceId
+                # 判断是否能添加 trace_id
                 if "application/json" in content_type and not content_disposition.startswith("attachment"):
                     try:
                         data = json.loads(response_body)
                         new_body = response_body
                         if data:
-                            data["traceId"] = trace_id  # 响应体也加入
+                            data["traceId"] = trace_id
                             new_body = json.dumps(
                                 data, ensure_ascii=False).encode()
 
-                        # 重建响应，确保 header 包含 x-traceId-header
+                        # 创建新响应，确保Content-Length正确
                         response = Response(
                             content=new_body,
                             status_code=response.status_code,
                             headers=dict(response.headers),
                             media_type=response.media_type
                         )
-                        response.headers["content-length"] = str(len(new_body))
-                        response.headers["x-traceId-header"] = trace_id  # 再次兜底
-                        # 恢复 CORS 头
-                        for k, v in cors_headers.items():
-                            response.headers[k] = v
+                        # 显式设置正确的Content-Length
+                        response.headers["Content-Length"] = str(len(new_body))
                     except json.JSONDecodeError:
-                        # 非 JSON 响应：仅更新长度，强制加入 traceId
+                        # 如果不是JSON，恢复原始响应体并更新长度
                         response = Response(
                             content=response_body,
                             status_code=response.status_code,
                             headers=dict(response.headers),
                             media_type=response.media_type
                         )
-                        response.headers["content-length"] = str(
+                        response.headers["Content-Length"] = str(
                             len(response_body))
-                        response.headers["x-traceId-header"] = trace_id  # 强制加入
-                        for k, v in cors_headers.items():
-                            response.headers[k] = v
                 else:
-                    # 非 JSON 响应：强制加入 traceId
+                    # 非JSON响应，恢复原始响应体
                     response = Response(
                         content=response_body,
                         status_code=response.status_code,
                         headers=dict(response.headers),
                         media_type=response.media_type
                     )
-                    response.headers["content-length"] = str(
+                    response.headers["Content-Length"] = str(
                         len(response_body))
-                    response.headers["x-traceId-header"] = trace_id  # 强制加入
-                    for k, v in cors_headers.items():
-                        response.headers[k] = v
             except StopAsyncIteration:
                 pass
 
-            # 构建响应日志（包含 traceId）
+            # 构建响应日志信息
             response_message = {
-                "traceId": trace_id,  # 响应日志加入 traceId
                 "status_code": response.status_code,
                 "response_body": response_body.decode('utf-8', errors='ignore'),
             }
@@ -258,21 +148,11 @@ def setup_trace_id_handler(app):
                 response_message, ensure_ascii=False)
             SYLogger.info(response_message_str)
 
-            # ========== 最终兜底：确保响应头必有 x-traceId-header ==========
-            try:
-                response.headers["x-traceId-header"] = trace_id
-            except AttributeError:
-                new_headers = dict(response.headers) if hasattr(
-                    response.headers, 'items') else {}
-                new_headers["x-traceId-header"] = trace_id
-                if hasattr(response, "init_headers"):
-                    response.init_headers(new_headers)
+            response.headers["x-traceId-header"] = trace_id
 
             return response
         except Exception as e:
-            # 异常日志也加入 traceId
             error_message = {
-                "traceId": trace_id,
                 "error": str(e),
                 "query_params": query_params,
                 "request_body": request_body,
@@ -282,8 +162,7 @@ def setup_trace_id_handler(app):
             SYLogger.error(error_message_str)
             raise
         finally:
-            # 清理上下文变量
+            # 清理上下文变量，防止泄漏
             SYLogger.reset_trace_id(token)
-            SYLogger.reset_headers(header_token)
 
     return app

sycommon/services.py

@@ -7,7 +7,6 @@ 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
@@ -24,9 +23,6 @@ class Services(metaclass=SingletonMeta):
     _user_lifespan: Optional[Callable] = None
     _shutdown_lock: asyncio.Lock = asyncio.Lock()
 
-    # 用于存储待执行的异步数据库初始化任务
-    _pending_async_db_setup: List[Tuple[Callable, str]] = []
-
     def __init__(self, config: dict, app: FastAPI):
         if not Services._config:
             Services._config = config
@@ -52,25 +48,25 @@ class Services(metaclass=SingletonMeta):
         nacos_service: Optional[Callable[[dict], None]] = None,
         logging_service: Optional[Callable[[dict], None]] = None,
         database_service: Optional[Union[
-            Tuple[Callable, str],
-            List[Tuple[Callable, str]]
+            Tuple[Callable[[dict, str], None], str],
+            List[Tuple[Callable[[dict, str], None], 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
         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
         app.state.config = {
             "host": cls._config.get('Host', '0.0.0.0'),
             "port": cls._config.get('Port', 8080),
@@ -78,6 +74,7 @@ class Services(metaclass=SingletonMeta):
             "h11_max_incomplete_event_size": cls._config.get('H11MaxIncompleteEventSize', 1024 * 1024 * 10)
         }
 
+        # 立即配置非异步服务（在应用启动前）
         if middleware:
             middleware(app, config)
 
@@ -87,29 +84,8 @@ class Services(metaclass=SingletonMeta):
         if logging_service:
             logging_service(config)
 
-        # ========== 处理数据库服务 ==========
-        # 清空之前的待执行列表（防止热重载时重复）
-        cls._pending_async_db_setup = []
-
         if database_service:
-            # 解析配置并区分同步/异步
-            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}，将在应用启动时初始化")
-                    cls._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
+            cls._setup_database_static(database_service, config)
 
         # 创建组合生命周期管理器
         @asynccontextmanager
@@ -117,25 +93,14 @@ class Services(metaclass=SingletonMeta):
             # 1. 执行Services自身的初始化
             instance = cls(config, app)
 
-            # ========== 执行挂起的异步数据库初始化 ==========
-            if cls._pending_async_db_setup:
-                logging.info("开始执行异步数据库初始化...")
-                for db_setup_func, db_name in cls._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
-
-            # ========== 初始化 MQ ==========
+            # 明确判断是否有有效的监听器/发送器配置
             has_valid_listeners = bool(
                 rabbitmq_listeners and len(rabbitmq_listeners) > 0)
             has_valid_senders = bool(
                 rabbitmq_senders and len(rabbitmq_senders) > 0)
 
             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,
@@ -154,18 +119,28 @@ class Services(metaclass=SingletonMeta):
             # 2. 执行用户定义的生命周期
             if cls._user_lifespan:
                 async with cls._user_lifespan(app):
-                    yield
+                    yield  # 应用运行阶段
             else:
-                yield
+                yield  # 没有用户生命周期时直接 yield
 
             # 3. 执行Services的关闭逻辑
             await cls.shutdown()
             logging.info("Services已关闭")
 
+        # 设置组合生命周期
         app.router.lifespan_context = combined_lifespan
+
         return app
 
-    # 移除了 _setup_database_static，因为逻辑已内联到 plugins 中
+    @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,
@@ -174,13 +149,16 @@ class Services(metaclass=SingletonMeta):
         has_listeners: bool = False,
         has_senders: bool = False,
     ):
-        """异步设置MQ相关服务"""
+        """异步设置MQ相关服务（适配单通道RabbitMQService）"""
+        # ========== 只有需要使用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:
@@ -188,7 +166,10 @@ class Services(metaclass=SingletonMeta):
             logging.info("等待RabbitMQ连接池初始化...")
             await asyncio.sleep(0.5)
 
+        # ========== 保留原有严格的发送器/监听器初始化判断 ==========
+        # 只有配置了发送器才执行发送器初始化
         if has_senders and rabbitmq_senders:
+            # 判断是否有监听器，如果有遍历监听器列表，队列名一样将prefetch_count属性设置到发送器对象中
             if has_listeners and rabbitmq_listeners:
                 for sender in rabbitmq_senders:
                     for listener in rabbitmq_listeners:
@@ -196,25 +177,31 @@ 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}")
 
     async def _setup_listeners_async(self, rabbitmq_listeners, has_senders: bool):
-        """设置监听器"""
+        """设置监听器（适配新的RabbitMQService异步方法）"""
         await RabbitMQService.setup_listeners(rabbitmq_listeners, has_senders)
 
     @classmethod
@@ -225,7 +212,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("服务未正确初始化")
@@ -236,15 +223,18 @@ 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方法）
                 sender = await RabbitMQService.get_sender(queue_name)
                 if not sender:
                     raise ValueError(f"发送器 '{queue_name}' 不存在或连接无效")
 
+                # 发送消息（调用RabbitMQService的异步send_message）
                 await RabbitMQService.send_message(data, queue_name, **kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
                 return
@@ -254,18 +244,25 @@ class Services(metaclass=SingletonMeta):
                     logging.error(
                         f"消息发送失败（已尝试 {max_retries} 次）: {str(e)}", exc_info=True)
                     raise
+
                 logging.warning(
-                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，{retry_delay}秒后重试...")
+                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，"
+                    f"{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()
+
+            # 清理全局状态
             cls._initialized = False
             cls._registered_senders.clear()
             logging.info("所有服务已关闭")

sycommon/synacos/feign.py

@@ -2,7 +2,6 @@ import io
 import os
 import time
 
-from sycommon.tools.merge_headers import merge_headers
 from sycommon.tools.snowflake import Snowflake
 
 import aiohttp
@@ -25,18 +24,14 @@ async def feign(service_name, api_path, method='GET', params=None, headers=None,
     try:
         # 初始化headers，确保是可修改的字典
         headers = headers.copy() if headers else {}
-        headers = merge_headers(SYLogger.get_headers(), headers)
         if "x-traceId-header" not in headers:
             headers["x-traceId-header"] = SYLogger.get_trace_id() or Snowflake.id
 
         # 处理JSON请求的Content-Type
         is_json_request = method.upper() in ["POST", "PUT", "PATCH"] and not (
             files or form_data or file_path)
-        if is_json_request:
-            # 将headers的key全部转为小写，统一判断
-            headers_lower = {k.lower(): v for k, v in headers.items()}
-            if "content-type" not in headers_lower:
-                headers["Content-Type"] = "application/json"
+        if is_json_request and "Content-Type" not in headers:
+            headers["Content-Type"] = "application/json"
 
         nacos_service = NacosService(None)
         version = headers.get('s-y-version')
@@ -52,7 +47,7 @@ async def feign(service_name, api_path, method='GET', params=None, headers=None,
         instance = instances[int(time.time()) % len(instances)]
 
         SYLogger.info(f"nacos:开始调用服务: {service_name}")
-        # SYLogger.info(f"nacos:请求头: {headers}")
+        SYLogger.info(f"nacos:请求头: {headers}")
 
         ip = instance.get('ip')
         port = instance.get('port')