sycommon-python-lib 0.1.55__tar.gz → 0.1.55a0__tar.gz

{sycommon_python_lib-0.1.55 → sycommon_python_lib-0.1.55a0}/PKG-INFO

@@ -1,25 +1,25 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.55
+Version: 0.1.55a0
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: aio-pika>=9.5.8
 Requires-Dist: aiohttp>=3.13.2
-Requires-Dist: aiomysql>=0.3.2
 Requires-Dist: decorator>=5.2.1
-Requires-Dist: fastapi>=0.127.0
-Requires-Dist: kafka-python>=2.3.0
+Requires-Dist: fastapi>=0.121.2
+Requires-Dist: kafka-python>=2.2.16
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mysql-connector-python>=9.5.0
 Requires-Dist: nacos-sdk-python<3.0,>=2.0.9
-Requires-Dist: psutil>=7.1.3
-Requires-Dist: pydantic>=2.12.5
+Requires-Dist: netifaces>=0.11.0
+Requires-Dist: pydantic>=2.12.4
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: sqlalchemy[asyncio]>=2.0.45
-Requires-Dist: starlette>=0.50.0
-Requires-Dist: uvicorn>=0.40.0
+Requires-Dist: sqlalchemy>=2.0.44
+Requires-Dist: starlette>=0.49.3
+Requires-Dist: uuid>=1.30
+Requires-Dist: uvicorn>=0.38.0
 
 # sycommon-python-lib
 

{sycommon_python_lib-0.1.55 → sycommon_python_lib-0.1.55a0}/pyproject.toml

@@ -1,26 +1,26 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.55"
+version = "0.1.55-alpha"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
     "aio-pika>=9.5.8",
     "aiohttp>=3.13.2",
-    "aiomysql>=0.3.2",
     "decorator>=5.2.1",
-    "fastapi>=0.127.0",
-    "kafka-python>=2.3.0",
+    "fastapi>=0.121.2",
+    "kafka-python>=2.2.16",
     "loguru>=0.7.3",
     "mysql-connector-python>=9.5.0",
     "nacos-sdk-python>=2.0.9,<3.0",
-    "psutil>=7.1.3",
-    "pydantic>=2.12.5",
+    "netifaces>=0.11.0",
+    "pydantic>=2.12.4",
     "python-dotenv>=1.2.1",
     "pyyaml>=6.0.3",
-    "sqlalchemy[asyncio]>=2.0.45",
-    "starlette>=0.50.0",
-    "uvicorn>=0.40.0",
+    "sqlalchemy>=2.0.44",
+    "starlette>=0.49.3",
+    "uuid>=1.30",
+    "uvicorn>=0.38.0",
 ]
 
 [tool.setuptools]

{sycommon_python_lib-0.1.55 → sycommon_python_lib-0.1.55a0}/src/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的颜色方案
@@ -114,7 +114,7 @@ class KafkaLogger(metaclass=SingletonMeta):
                     trace_id = None
 
                 if not trace_id:
-                    trace_id = SYLogger.get_trace_id() or Snowflake.id
+                    trace_id = SYLogger.get_trace_id() or Snowflake.next_id()
 
                 # 获取线程/协程信息
                 thread_info = SYLogger._get_execution_context()
@@ -173,7 +173,7 @@ class KafkaLogger(metaclass=SingletonMeta):
                     "className": "",
                     "sqlCost": 0,
                     "size": len(str(message)),
-                    "uid": int(Snowflake.id)  # 独立新的id
+                    "uid": int(Snowflake.next_id())  # 独立新的id
                 }
 
                 # 智能队列管理
@@ -212,7 +212,7 @@ class KafkaLogger(metaclass=SingletonMeta):
             return
 
         # 获取当前的trace_id
-        trace_id = SYLogger.get_trace_id() or Snowflake.id
+        trace_id = SYLogger.get_trace_id() or Snowflake.next_id()
 
         # 构建错误日志
         error_log = {
@@ -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:
         """获取当前执行上下文的线程或协程信息，返回格式化字符串"""
@@ -471,7 +459,7 @@ class SYLogger:
 
     @staticmethod
     def _log(msg: any, level: str = "INFO"):
-        trace_id = SYLogger.get_trace_id() or Snowflake.id
+        trace_id = SYLogger.get_trace_id() or Snowflake.next_id()
 
         if isinstance(msg, dict) or isinstance(msg, list):
             msg_str = json.dumps(msg, ensure_ascii=False)
@@ -485,7 +473,7 @@ class SYLogger:
         request_log = {}
         if level == "ERROR":
             request_log = {
-                "trace_id": str(trace_id) if trace_id else Snowflake.id,
+                "trace_id": str(trace_id) if trace_id else Snowflake.next_id(),
                 "message": msg_str,
                 "traceback": traceback.format_exc(),
                 "level": level,
@@ -493,7 +481,7 @@ class SYLogger:
             }
         else:
             request_log = {
-                "trace_id": str(trace_id) if trace_id else Snowflake.id,
+                "trace_id": str(trace_id) if trace_id else Snowflake.next_id(),
                 "message": msg_str,
                 "level": level,
                 "threadName": thread_info
@@ -533,7 +521,7 @@ class SYLogger:
     @staticmethod
     def exception(msg: any, *args, **kwargs):
         """记录异常信息，包括完整堆栈"""
-        trace_id = SYLogger.get_trace_id() or Snowflake.id
+        trace_id = SYLogger.get_trace_id() or Snowflake.next_id()
 
         if isinstance(msg, dict) or isinstance(msg, list):
             msg_str = json.dumps(msg, ensure_ascii=False)
@@ -545,7 +533,7 @@ class SYLogger:
 
         # 构建包含异常堆栈的日志
         request_log = {
-            "trace_id": str(trace_id) if trace_id else Snowflake.id,
+            "trace_id": str(trace_id) if trace_id else Snowflake.next_id(),
             "message": msg_str,
             "level": "ERROR",
             "threadName": thread_info

{sycommon_python_lib-0.1.55 → sycommon_python_lib-0.1.55a0}/src/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_python_lib-0.1.55a0/src/sycommon/middleware/traceid.py

@@ -0,0 +1,166 @@
+import json
+import re
+from typing import Dict, Any
+from fastapi import Request, Response
+from sycommon.logging.kafka_log import SYLogger
+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):
+        # 生成或获取 traceId
+        trace_id = request.headers.get("x-traceId-header")
+        if not trace_id:
+            trace_id = Snowflake.next_id()
+
+        # 设置 trace_id 上下文
+        token = SYLogger.set_trace_id(trace_id)
+
+        # 获取请求参数
+        query_params = dict(request.query_params)
+        request_body: Dict[str, Any] = {}
+        files_info: Dict[str, str] = {}
+
+        # 检测请求内容类型
+        content_type = request.headers.get("content-type", "").lower()
+
+        if "application/json" in content_type and request.method in ["POST", "PUT", "PATCH"]:
+            try:
+                request_body = await request.json()
+            except Exception as 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:
+                # 从请求头中提取boundary
+                boundary = None
+                if "boundary=" in content_type:
+                    boundary = content_type.split("boundary=")[1].strip()
+                    boundary = boundary.encode('ascii')
+
+                if boundary:
+                    # 读取原始请求体
+                    body = await request.body()
+
+                    # 尝试从原始请求体中提取文件名
+                    parts = body.split(boundary)
+                    for part in parts:
+                        part_str = part.decode('utf-8', errors='ignore')
+
+                        # 使用正则表达式查找文件名
+                        filename_match = re.search(
+                            r'filename="([^"]+)"', part_str)
+                        if filename_match:
+                            field_name_match = re.search(
+                                r'name="([^"]+)"', part_str)
+                            field_name = field_name_match.group(
+                                1) if field_name_match else "unknown"
+                            filename = filename_match.group(1)
+                            files_info[field_name] = filename
+            except Exception as e:
+                request_body = {
+                    "error": f"Failed to process form data: {str(e)}"}
+
+        # 构建请求日志信息
+        request_message = {
+            "method": request.method,
+            "url": str(request.url),
+            "query_params": query_params,
+            "request_body": request_body,
+            "uploaded_files": files_info if files_info else None
+        }
+        request_message_str = json.dumps(request_message, ensure_ascii=False)
+        SYLogger.info(request_message_str)
+
+        try:
+            # 处理请求
+            response = await call_next(request)
+
+            content_type = response.headers.get("Content-Type", "")
+
+            # 处理 SSE 响应
+            if "text/event-stream" in content_type:
+                # 流式响应不能有Content-Length，移除它
+                if "Content-Length" in response.headers:
+                    del response.headers["Content-Length"]
+                response.headers["x-traceId-header"] = trace_id
+                return response
+
+            # 处理普通响应
+            response_body = b""
+            try:
+                # 收集所有响应块
+                async for chunk in response.body_iterator:
+                    response_body += chunk
+
+                content_disposition = response.headers.get(
+                    "Content-Disposition", "")
+
+                # 判断是否能添加 trace_id
+                if "application/json" in content_type and not content_disposition.startswith("attachment"):
+                    try:
+                        data = json.loads(response_body)
+                        data["traceId"] = trace_id
+                        new_body = json.dumps(
+                            data, ensure_ascii=False).encode()
+
+                        # 创建新响应，确保Content-Length正确
+                        response = Response(
+                            content=new_body,
+                            status_code=response.status_code,
+                            headers=dict(response.headers),
+                            media_type=response.media_type
+                        )
+                        # 显式设置正确的Content-Length
+                        response.headers["Content-Length"] = str(len(new_body))
+                    except json.JSONDecodeError:
+                        # 如果不是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(
+                            len(response_body))
+                else:
+                    # 非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(
+                        len(response_body))
+            except StopAsyncIteration:
+                pass
+
+            # 构建响应日志信息
+            response_message = {
+                "status_code": response.status_code,
+                "response_body": response_body.decode('utf-8', errors='ignore'),
+            }
+            response_message_str = json.dumps(
+                response_message, ensure_ascii=False)
+            SYLogger.info(response_message_str)
+
+            response.headers["x-traceId-header"] = trace_id
+
+            return response
+        except Exception as e:
+            error_message = {
+                "error": str(e),
+                "query_params": query_params,
+                "request_body": request_body,
+                "uploaded_files": files_info if files_info else None
+            }
+            error_message_str = json.dumps(error_message, ensure_ascii=False)
+            SYLogger.error(error_message_str)
+            raise
+        finally:
+            # 清理上下文变量，防止泄漏
+            SYLogger.reset_trace_id(token)
+
+    return app

{sycommon_python_lib-0.1.55 → sycommon_python_lib-0.1.55a0}/src/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_python_lib-0.1.55 → sycommon_python_lib-0.1.55a0}/src/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
+            headers["x-traceId-header"] = SYLogger.get_trace_id() or Snowflake.next_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')