sycommon-python-lib 0.1.0__py3-none-any.whl

sycommon/middleware/middleware.py

@@ -0,0 +1,32 @@
+from sycommon.health.ping import setup_ping_handler
+from sycommon.middleware.cors import setup_cors_handler
+from sycommon.middleware.exception import setup_exception_handler
+from sycommon.middleware.monitor_memory import setup_monitor_memory_middleware
+from sycommon.middleware.timeout import setup_request_timeout_middleware
+from sycommon.middleware.traceid import setup_trace_id_handler
+from sycommon.health.health_check import setup_health_handler
+
+
+def setup_middleware(app, config: dict):
+    # 设置请求超时中间件
+    app = setup_request_timeout_middleware(app, config)
+
+    # 设置异常处理
+    app = setup_exception_handler(app, config)
+
+    # 设置 trace_id 处理中间件
+    app = setup_trace_id_handler(app)
+
+    # 设置内存监控中间件
+    # app = setup_monitor_memory_middleware(app)
+
+    # 设置cors
+    # app = setup_cors_handler(app)
+
+    # 健康检查
+    app = setup_health_handler(app)
+
+    # ping
+    app = setup_ping_handler(app)
+
+    return app

sycommon/middleware/monitor_memory.py

@@ -0,0 +1,22 @@
+
+import tracemalloc
+from fastapi import Request
+
+from sycommon.logging.kafka_log import SYLogger
+
+
+def setup_monitor_memory_middleware(app):
+    @app.middleware("http")
+    async def before_request(request: Request, call_next):
+        # if not tracemalloc.is_tracing():
+        #     tracemalloc.start()
+
+        # snapshot1 = tracemalloc.take_snapshot()
+        # await call_next(request)
+        # snapshot2 = tracemalloc.take_snapshot()
+
+        # top_stats = snapshot2.compare_to(snapshot1, 'lineno')
+        # if top_stats:
+        #     SYLogger.info(f"内存增长最大项: {top_stats[0]}")
+        pass
+    return app

sycommon/middleware/timeout.py

@@ -0,0 +1,19 @@
+
+import time
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+
+def setup_request_timeout_middleware(app, config: dict):
+    # 设置全局请求超时时间
+    REQUEST_TIMEOUT = int(config.get('Timeout', 30000))/1000
+
+    @app.middleware("http")
+    async def before_request(request: Request, call_next):
+        request.state.start_time = time.time()
+        response = await call_next(request)
+        duration = time.time() - request.state.start_time
+        if duration > REQUEST_TIMEOUT:
+            return JSONResponse(content={'code': 1, 'error': 'Request timed out'}, status_code=504)
+        return response
+    return app

sycommon/middleware/traceid.py

@@ -0,0 +1,138 @@
+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", "")
+            if "text/event-stream" in content_type:
+                # 处理 SSE 响应
+                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["trace_id"] = trace_id
+                        new_body = json.dumps(
+                            data, ensure_ascii=False).encode()
+                        response = Response(
+                            content=new_body,
+                            status_code=response.status_code,
+                            headers=dict(response.headers)
+                        )
+                        response.headers["Content-Length"] = str(len(new_body))
+                    except json.JSONDecodeError:
+                        pass
+            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)  # 无需显式传递 trace_id
+            raise
+        finally:
+            # 清理上下文变量，防止泄漏
+            SYLogger.reset_trace_id(token)
+
+    return app

sycommon/models/log.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel
+
+
+class LogModel(BaseModel):
+    traceId: str
+    sySpanId: str
+    syBizId: str
+    ptxId: str
+    time: str
+    day: str
+    msg: str
+    detail: str
+    IP: str
+    hostName: str
+    tenantId: str
+    userId: str
+    customerId: str
+    env: str
+    priReqSource: str
+    reqSource: str
+    serviceId: str
+    logLevel: str
+    classShortName: str
+    method: str
+    line: str
+    theadName: str
+    className: str
+    sqlCost: float
+    size: float
+    uid: float

sycommon/services.py

@@ -0,0 +1,29 @@
+from typing import Callable, List, Tuple
+
+from sycommon.config.Config import SingletonMeta
+
+
+class Services(metaclass=SingletonMeta):
+    def __init__(self, config):
+        self.config = config
+
+    def plugins(self, nacos_service=None, logging_service=None, database_service: Tuple[Callable, str] | List[Tuple[Callable, str]] = None):
+        # 注册nacos服务
+        if nacos_service:
+            nacos_service(self.config)
+        # 注册日志服务
+        if logging_service:
+            logging_service(self.config)
+        # 注册数据库服务
+        if database_service:
+            if isinstance(database_service, tuple):
+                # 单个数据库服务
+                db_setup, db_name = database_service
+                db_setup(self.config, db_name)
+            elif isinstance(database_service, list):
+                # 多个数据库服务
+                for db_setup, db_name in database_service:
+                    db_setup(self.config, db_name)
+            else:
+                raise TypeError(
+                    "database_service must be a tuple or a list of tuples")

sycommon/synacos/feign.py

@@ -0,0 +1,307 @@
+import io
+import os
+import time
+from urllib.parse import urljoin
+
+import aiohttp
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.synacos.nacos_service import NacosService
+
+"""
+支持异步Feign客户端
+    方式一: 使用 @feign_client 和 @feign_request 装饰器
+    方式二: 使用 feign 函数
+"""
+
+# 示例Feign客户端接口
+# @feign_client(service_name="user-service", path_prefix="/api/v1")
+# class UserServiceClient:
+#
+#     @feign_request("GET", "/users/{user_id}")
+#     async def get_user(self, user_id):
+#         """获取用户信息"""
+#         pass
+#
+#     @feign_request("POST", "/users", headers={"Content-Type": "application/json"})
+#     async def create_user(self, user_data):
+#         """创建用户"""
+#         pass
+#
+#     @feign_upload("avatar")
+#     @feign_request("POST", "/users/{user_id}/avatar")
+#     async def upload_avatar(self, user_id, file_path):
+#         """上传用户头像"""
+#         pass
+
+# # 使用示例
+# async def get_user_info(user_id: int, request=None):
+#     """获取用户信息"""
+#     try:
+#         user_service = UserServiceClient()
+#         # 设置请求头中的版本信息
+#         user_service.get_user._feign_meta['headers']['s-y-version'] = "1.0.0"
+#         return await user_service.get_user(user_id=user_id, request=request)
+#     except Exception as e:
+#         SYLogger.error(f"获取用户信息失败: {str(e)}", TraceId(request))
+#         return None
+
+
+def feign_client(service_name: str, path_prefix: str = ""):
+    # Feign风格客户端装饰器
+    """声明式HTTP客户端装饰器"""
+    def decorator(cls):
+        class FeignWrapper:
+            def __init__(self):
+                self.service_name = service_name
+                self.nacos_manager = NacosService(None)
+                self.path_prefix = path_prefix
+                self.session = aiohttp.ClientSession()
+
+            def __getattr__(self, name):
+                func = getattr(cls, name)
+
+                async def wrapper(*args, **kwargs):
+                    # 获取请求元数据
+                    request_meta = getattr(func, "_feign_meta", {})
+                    method = request_meta.get("method", "GET")
+                    path = request_meta.get("path", "")
+                    headers = request_meta.get("headers", {})
+
+                    # 获取版本信息
+                    version = headers.get('s-y-version')
+
+                    # 构建完整URL
+                    full_path = f"{self.path_prefix}{path}"
+                    for k, v in kwargs.items():
+                        full_path = full_path.replace(f"{{{k}}}", str(v))
+
+                    # 服务发现与负载均衡
+                    instances = self.nacos_manager.get_service_instances(
+                        self.service_name, version=version)
+                    if not instances:
+                        SYLogger.error(
+                            f"nacos:未找到 {self.service_name} 的健康实例")
+                        raise RuntimeError(
+                            f"No instances available for {self.service_name}")
+
+                    # 简单轮询负载均衡
+                    instance = instances[int(time.time()) % len(instances)]
+                    base_url = f"http://{instance['ip']}:{instance['port']}"
+                    url = urljoin(base_url, full_path)
+
+                    SYLogger.info(
+                        f"nacos:调用服务: {self.service_name} -> {url}")
+
+                    # 构建请求
+                    params = request_meta.get("params", {})
+                    body = request_meta.get("body", {})
+                    files = request_meta.get("files", None)
+                    form_data = request_meta.get("form_data", None)
+
+                    # 发送请求
+                    try:
+                        # 处理文件上传
+                        if files or form_data:
+                            # 创建表单数据
+                            data = aiohttp.FormData()
+                            if form_data:
+                                for key, value in form_data.items():
+                                    data.add_field(key, value)
+                            if files:
+                                for field_name, (filename, content) in files.items():
+                                    data.add_field(
+                                        field_name, content, filename=filename)
+                            # 移除 Content-Type 头，让 aiohttp 自动设置 boundary
+                            headers.pop('Content-Type', None)
+                            # 发送表单数据
+                            async with self.session.request(
+                                method=method,
+                                url=url,
+                                headers=headers,
+                                params=params,
+                                data=data,
+                                timeout=10
+                            ) as response:
+                                return await self._handle_response(response)
+                        else:
+                            # 普通请求
+                            async with self.session.request(
+                                method=method,
+                                url=url,
+                                headers=headers,
+                                params=params,
+                                json=body,
+                                timeout=10
+                            ) as response:
+                                return await self._handle_response(response)
+                    except Exception as e:
+                        SYLogger.error(f"nacos:服务调用失败: {str(e)}")
+                        raise RuntimeError(f"Feign call failed: {str(e)}")
+
+                return wrapper
+
+            async def _handle_response(self, response):
+                # 处理响应
+                if 200 <= response.status < 300:
+                    content_type = response.headers.get('Content-Type', '')
+                    if 'application/json' in content_type:
+                        return await response.json()
+                    else:
+                        return await response.read()
+                raise RuntimeError(
+                    f"请求失败: {response.status} - {await response.text()}")
+
+            async def close(self):
+                """关闭 aiohttp 会话"""
+                await self.session.close()
+
+        return FeignWrapper()
+    return decorator
+
+
+def feign_request(method: str, path: str, headers: dict = None):
+    # Feign请求方法装饰器
+    def decorator(func):
+        func._feign_meta = {
+            "method": method.upper(),
+            "path": path,
+            "headers": headers or {}
+        }
+        return func
+    return decorator
+
+
+def feign_upload(field_name: str = "file"):
+    # 文件上传装饰器
+    def decorator(func):
+        async def wrapper(*args, **kwargs):
+            file_path = kwargs.get('file_path')
+            if not file_path:
+                raise ValueError("file_path is required for upload")
+
+            with open(file_path, 'rb') as f:
+                files = {field_name: (os.path.basename(file_path), f.read())}
+                kwargs['files'] = files
+                return await func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+
+async def feign(service_name, api_path, method='GET', params=None, headers=None, file_path=None,
+                path_params=None, request=None, body=None, files=None, form_data=None):
+    """
+    feign 函数，支持 form-data 表单上传文件和其他字段
+
+    参数:
+        files: 字典，用于上传文件，格式: {'field_name': (filename, file_content)}
+        form_data: 字典，用于上传表单字段
+    """
+    file_stream = None
+    session = aiohttp.ClientSession()
+    try:
+        # 获取健康的服务实例
+        if not headers:
+            headers = {}
+
+        nacos_service = NacosService(None)
+        version = headers.get('s-y-version')
+
+        # 使用 discover_services 方法获取服务实例列表
+        instances = nacos_service.get_service_instances(
+            service_name, version=version)
+        if not instances:
+            SYLogger.error(f"nacos:未找到 {service_name} 的健康实例")
+            return None
+
+        # 简单轮询负载均衡
+        instance = instances[int(time.time()) % len(instances)]
+
+        SYLogger.info(f"nacos:开始调用服务: {service_name}")
+        SYLogger.info(
+            f"nacos:服务实例信息: IP={instance['ip']}, Port={instance['port']}")
+
+        if instance:
+            ip = instance.get('ip')
+            port = instance.get('port')
+
+            SYLogger.info(f"nacos:服务实例信息: IP={ip}, Port={port}")
+
+            # 处理 path 参数
+            if path_params:
+                for key, value in path_params.items():
+                    api_path = api_path.replace(f"{{{key}}}", str(value))
+
+            url = f"http://{ip}:{port}{api_path}"
+            SYLogger.info(f"nacos:请求地址: {url}")
+
+            try:
+                # 处理文件上传
+                if files or form_data or file_path:
+                    # 创建表单数据
+                    data = aiohttp.FormData()
+                    if form_data:
+                        for key, value in form_data.items():
+                            data.add_field(key, value)
+                    if files:
+                        for field_name, (filename, content) in files.items():
+                            data.add_field(field_name, content,
+                                           filename=filename)
+                    if file_path:
+                        filename = os.path.basename(file_path)
+                        with open(file_path, 'rb') as f:
+                            data.add_field('file', f, filename=filename)
+                    # 移除 Content-Type 头，让 aiohttp 自动设置 boundary
+                    headers.pop('Content-Type', None)
+                    # 发送表单数据
+                    async with session.request(
+                        method=method.upper(),
+                        url=url,
+                        headers=headers,
+                        params=params,
+                        data=data,
+                        timeout=10
+                    ) as response:
+                        return await _handle_feign_response(response)
+                else:
+                    # 普通请求
+                    if body and 'Content-Type' not in headers:
+                        headers['Content-Type'] = 'application/json'
+                    async with session.request(
+                        method=method.upper(),
+                        url=url,
+                        headers=headers,
+                        params=params,
+                        json=body,
+                        timeout=10
+                    ) as response:
+                        return await _handle_feign_response(response)
+            except aiohttp.ClientError as e:
+                SYLogger.error(
+                    f"nacos:请求服务接口时出错ClientError: {e}")
+                print(f"请求服务接口时出错: {e}")
+                return None
+    except Exception as e:
+        SYLogger.error(f"nacos:请求服务接口时出错: {e}")
+        print(f"nacos:请求服务接口时出错: {e}")
+        return None
+    finally:
+        SYLogger.info(f"nacos:结束调用服务: {service_name}， {api_path}")
+        await session.close()
+
+
+async def _handle_feign_response(response):
+    """处理Feign请求的响应"""
+    if response.status == 200:
+        content_type = response.headers.get('Content-Type')
+        if 'application/json' in content_type:
+            return await response.json()
+        else:
+            # 如果是文件流，将其封装成 io.BytesIO 对象返回
+            content = await response.read()
+            return io.BytesIO(content)
+    else:
+        print(
+            f"nacos:请求失败，状态码: {response.status}，响应内容: {await response.text()}")
+        SYLogger.error(
+            f"nacos:请求服务接口时出错: {response.status}, 响应内容: {await response.text()}")
+        return None