sycommon-python-lib 0.1.46__py3-none-any.whl → 0.1.57b1__py3-none-any.whl

sycommon/logging/logger_levels.py

@@ -0,0 +1,23 @@
+import logging
+
+
+def setup_logger_levels():
+    """配置各模块的日志级别，抑制无关INFO/DEBUG日志"""
+    # Nacos 客户端：仅输出WARNING及以上（屏蔽INFO级的心跳/注册日志）
+    logging.getLogger("nacos.client").setLevel(logging.WARNING)
+
+    # Kafka Python客户端：屏蔽INFO级的连接/版本检测日志
+    logging.getLogger("kafka.conn").setLevel(logging.WARNING)
+    logging.getLogger("kafka.producer").setLevel(logging.WARNING)
+
+    # Uvicorn/FastAPI：屏蔽启动/应用初始化的INFO日志（保留ERROR/WARNING）
+    # logging.getLogger("uvicorn").setLevel(logging.WARNING)
+    # logging.getLogger("uvicorn.access").setLevel(logging.WARNING)  # 屏蔽访问日志
+    # logging.getLogger("uvicorn.error").setLevel(logging.ERROR)     # 仅保留错误
+
+    # 自定义的root日志（如同步数据库/监听器初始化）：屏蔽INFO
+    logging.getLogger("root").setLevel(logging.WARNING)
+
+    # RabbitMQ相关日志（如果有专属日志器）
+    logging.getLogger("pika").setLevel(logging.WARNING)  # 若使用pika客户端
+    logging.getLogger("rabbitmq").setLevel(logging.WARNING)

sycommon/middleware/context.py

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

sycommon/middleware/exception.py

@@ -1,7 +1,7 @@
 from fastapi import Request, HTTPException
 from fastapi.responses import JSONResponse
 from pydantic import ValidationError
-import traceback
+from sycommon.logging.kafka_log import SYLogger
 
 
 def setup_exception_handler(app, config: dict):
@@ -15,7 +15,7 @@ def setup_exception_handler(app, config: dict):
         int_MaxBytes = int(MaxBytes) / 1024 / 1024
         return JSONResponse(
             content={
-                'code': 413, 'error': f'File size exceeds the allowed limit of {int_MaxBytes}MB.'},
+                'code': 413, 'error': f'File size exceeds the allowed limit of {int_MaxBytes}MB.', 'traceId': SYLogger.get_trace_id()},
             status_code=413
         )
 
@@ -27,7 +27,8 @@ def setup_exception_handler(app, config: dict):
             content={
                 "code": exc.status_code,
                 "message": exc.detail,
-                "path": str(request.url.path)
+                "path": str(request.url.path),
+                "traceId": SYLogger.get_trace_id()
             }
         )
 
@@ -39,7 +40,8 @@ def setup_exception_handler(app, config: dict):
             content={
                 "code": 400,
                 "message": "参数验证失败",
-                "details": exc.errors()
+                "details": exc.errors(),
+                "traceId": SYLogger.get_trace_id()
             }
         )
 
@@ -55,30 +57,22 @@ def setup_exception_handler(app, config: dict):
             status_code=exc.code,
             content={
                 "code": exc.code,
-                "message": exc.message
+                "message": exc.message,
+                "traceId": SYLogger.get_trace_id()
             }
         )
 
     # 5. 全局异常处理器（捕获所有未处理的异常）
     @app.exception_handler(Exception)
     async def global_exception_handler(request: Request, exc: Exception):
-        # 记录详细错误信息
-        error_msg = f"请求路径: {request.url}\n"
-        error_msg += f"错误类型: {type(exc).__name__}\n"
-        error_msg += f"错误信息: {str(exc)}\n"
-        error_msg += f"堆栈信息: {traceback.format_exc()}"
-
-        # 使用你的日志服务记录错误
-        from sycommon.logging.kafka_log import SYLogger
-        SYLogger.error(error_msg)
-
         # 返回统一格式的错误响应（生产环境可选择不返回详细信息）
         return JSONResponse(
             status_code=500,
             content={
                 "code": 500,
                 "message": "服务器内部错误，请稍后重试",
-                "detail": str(exc) if config.get('DEBUG', False) else "Internal Server Error"
+                "detail": str(exc) if config.get('DEBUG', False) else "Internal Server Error",
+                "traceId": SYLogger.get_trace_id()
             }
         )
 

sycommon/middleware/timeout.py

@@ -2,6 +2,7 @@
 import time
 from fastapi import Request
 from fastapi.responses import JSONResponse
+from sycommon.logging.kafka_log import SYLogger
 
 
 def setup_request_timeout_middleware(app, config: dict):
@@ -14,6 +15,6 @@ def setup_request_timeout_middleware(app, config: dict):
         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 JSONResponse(content={'code': 1, 'error': 'Request timed out', 'traceId': SYLogger.get_trace_id()}, status_code=504)
         return response
     return app

sycommon/middleware/traceid.py

@@ -3,52 +3,61 @@ 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):
-        # 生成或获取 traceId
-        trace_id = request.headers.get("x-traceId-header")
+        # ========== 1. 请求阶段：获取/生成 TraceID ==========
+        trace_id = request.headers.get("x-traceid-header")
         if not trace_id:
-            trace_id = Snowflake.next_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 "application/json" in content_type and request.method in ["POST", "PUT", "PATCH"]:
+        if is_json_content 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)}"}
+                # 兼容纯文本格式的 JSON
+                if "text/plain" in content_type:
+                    raw_text = await request.text(encoding="utf-8")
+                    request_body = json.loads(raw_text)
+                else:
+                    request_body = await request.json()
+            except Exception:
+                try:
+                    request_body = await request.json()
+                except Exception as e:
+                    request_body = {"error": f"JSON parse failed: {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:
@@ -62,105 +71,224 @@ def setup_trace_id_handler(app):
                 request_body = {
                     "error": f"Failed to process form data: {str(e)}"}
 
-        # 构建请求日志信息
+        # 构建请求日志
         request_message = {
+            "traceId": trace_id,
             "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)
+        SYLogger.info(json.dumps(request_message, ensure_ascii=False))
+
+        # 标记位：默认认为会发生异常
+        # 这样如果中途代码报错跳转到 except，finally 就不会 reset，保留 trace_id 给 Exception Handler
+        had_exception = True
 
         try:
-            # 处理请求
+            # ========== 2. 处理请求 ==========
             response = await call_next(request)
 
-            content_type = response.headers.get("Content-Type", "")
+            # ========== 3. 响应处理阶段 ==========
+            # 注意：此阶段发生的任何异常都会被下方的 except 捕获
+            # 从而保证 trace_id 不被清除，能够透传
 
-            # 处理 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
+            response_content_type = response.headers.get(
+                "content-type", "").lower()
+
+            # 处理 SSE (Server-Sent Events)
+            if "text/event-stream" in response_content_type:
+                try:
+                    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:
+                    # 流式响应头只读处理
+                    new_headers = dict(response.headers) if hasattr(
+                        response.headers, 'items') else {}
+                    new_headers["x-traceid-header"] = trace_id
+                    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"
+                    new_headers.pop("content-length", None)
+                    response.init_headers(new_headers)
+
+                # SSE 不处理 Body，直接返回
+                had_exception = False
                 return response
 
-            # 处理普通响应
+            # 处理非 SSE 响应
+            # 备份 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
+            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
+            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"
+
+            # 应用 Headers
+            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
+
+            # 处理响应体
             response_body = b""
             try:
-                # 收集所有响应块
                 async for chunk in response.body_iterator:
                     response_body += chunk
 
                 content_disposition = response.headers.get(
-                    "Content-Disposition", "")
+                    "content-disposition", "").lower()
 
-                # 判断是否能添加 trace_id
-                if "application/json" in content_type and not content_disposition.startswith("attachment"):
+                # JSON 响应体注入 traceId
+                if "application/json" in response_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()
+                        new_body = response_body
+                        if isinstance(data, dict):
+                            data["traceId"] = trace_id
+                            new_body = json.dumps(
+                                data, ensure_ascii=False).encode()
 
-                        # 创建新响应，确保Content-Length正确
+                        # 重建 Response 以更新 Body 和 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))
+                        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
                     except json.JSONDecodeError:
-                        # 如果不是JSON，恢复原始响应体并更新长度
+                        # 非 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响应，恢复原始响应体
+                    # 非 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
 
-            # 构建响应日志信息
+            # 构建响应日志
             response_message = {
+                "traceId": trace_id,
                 "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)
+            SYLogger.info(json.dumps(response_message, ensure_ascii=False))
 
-            response.headers["x-traceId-header"] = trace_id
+            # 兜底：确保 Header 必有 TraceId
+            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)
 
+            # 如果执行到这里，说明一切正常，标记为无异常
+            had_exception = False
             return response
+
         except Exception as e:
+            # ========== 4. 异常处理阶段 ==========
+            # 记录中间件层面的异常日志
             error_message = {
-                "error": str(e),
+                "traceId": trace_id,
+                "error": f"Middleware 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)
+            # 使用 SYLogger.error，由于处于 except 块，会自动捕获堆栈
+            SYLogger.error(error_message)
+
+            # 关键：重新抛出异常，让 Global Exception Handler 接管
+            # 此时 had_exception 仍为 True，finally 不会 reset，trace_id 得以保留
             raise
+
         finally:
-            # 清理上下文变量，防止泄漏
-            SYLogger.reset_trace_id(token)
+            # ========== 5. 清理阶段 ==========
+            # 只有在没有任何异常的情况下（had_exception=False），才手动清除上下文
+            if not had_exception:
+                SYLogger.reset_trace_id(token)
+                SYLogger.reset_headers(header_token)
+            # 如果 had_exception 为 True，这里什么都不做，保留 ContextVar 供 Exception Handler 读取
 
     return app

sycommon/notice/uvicorn_monitor.py

@@ -0,0 +1,200 @@
+from datetime import datetime
+import sys
+import traceback
+import aiohttp
+import asyncio
+import json
+from typing import Optional
+from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
+from sycommon.config.Config import Config
+from sycommon.logging.kafka_log import SYLogger
+
+
+async def send_wechat_markdown_msg(
+    content: str,
+    webhook: str = None
+) -> Optional[dict]:
+    """
+    异步发送企业微信Markdown格式的WebHook消息
+
+    Args:
+        content: Markdown格式的消息内容（支持企业微信支持的markdown语法）
+        webhook: 完整的企业微信WebHook URL（默认值包含key）
+
+    Returns:
+        接口返回的JSON数据（dict），失败返回None
+    """
+    # 设置请求头
+    headers = {
+        "Content-Type": "application/json; charset=utf-8"
+    }
+
+    # 构造请求体（Markdown格式）
+    payload = {
+        "msgtype": "markdown",
+        "markdown": {
+            "content": content
+        }
+    }
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                url=webhook,
+                data=json.dumps(payload, ensure_ascii=False),
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(total=10)
+            ) as response:
+                status = response.status
+                response_text = await response.text()
+                response_data = json.loads(
+                    response_text) if response_text else {}
+
+                if status == 200 and response_data.get("errcode") == 0:
+                    SYLogger.info(f"消息发送成功: {response_data}")
+                    return response_data
+                else:
+                    SYLogger.info(
+                        f"消息发送失败 - 状态码: {status}, 响应: {response_data}")
+                    return None
+    except Exception as e:
+        SYLogger.info(f"错误：未知异常 - {str(e)}")
+        return None
+
+
+async def send_webhook(error_info: dict = None, webhook: str = None):
+    """
+    发送服务启动结果的企业微信通知
+    Args:
+        error_info: 错误信息字典（启动失败时必填），包含：error_type, error_msg, stack_trace, elapsed_time
+        webhook: 完整的企业微信WebHook URL（覆盖默认值）
+    """
+    # 获取服务名和环境（兼容配置读取失败）
+    try:
+        service_name = Config().config.get('Name', "未知服务")
+        env = Config().config.get('Nacos', {}).get('namespaceId', '未知环境')
+        webHook = Config().config.get('llm', {}).get('WebHook', '未知环境')
+    except Exception as e:
+        service_name = "未知服务"
+        env = "未知环境"
+        webHook = None
+        SYLogger.info(f"读取配置失败: {str(e)}")
+
+    start_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+    # 启动失败的通知内容（包含详细错误信息）
+    error_type = error_info.get("error_type", "未知错误")
+    error_msg = error_info.get("error_msg", "无错误信息")
+    stack_trace = error_info.get("stack_trace", "无堆栈信息")[:500]  # 限制长度避免超限
+    elapsed_time = error_info.get("elapsed_time", 0)
+
+    markdown_content = f"""### {service_name}服务启动失败告警 ⚠️
+> 环境: <font color="warning">{env}</font>
+> 启动时间: <font color="comment">{start_time}</font>
+> 耗时: <font color="comment">{elapsed_time:.2f}秒</font>
+> 错误类型: <font color="danger">{error_type}</font>
+> 错误信息: <font color="danger">{error_msg}</font>
+> 错误堆栈: {stack_trace}"""
+
+    if webhook or webHook:
+        result = await send_wechat_markdown_msg(
+            content=markdown_content,
+            webhook=webhook or webHook
+        )
+        SYLogger.info(f"通知发送结果: {result}")
+    else:
+        SYLogger.info("未设置企业微信WebHook")
+
+
+def run(*args, webhook: str = None, **kwargs):
+    """
+    带企业微信告警的Uvicorn启动监控
+    调用方式1（默认配置）：uvicorn_monitor.run("app:app", **app.state.config)
+    调用方式2（自定义webhook）：uvicorn_monitor.run("app:app", webhook="完整URL", **app.state.config)
+
+    Args:
+        *args: 传递给uvicorn.run的位置参数（如"app:app"）
+        webhook: 完整的企业微信WebHook URL（可选，覆盖默认值）
+        **kwargs: 传递给uvicorn.run的关键字参数（如app.state.config）
+    """
+    # 判断环境
+    env = Config().config.get('Nacos', {}).get('namespaceId', '未知环境')
+    if env == "prod":
+        import uvicorn
+        uvicorn.run(*args, **kwargs)
+        return
+
+    # 记录启动开始时间
+    start_time = datetime.now()
+
+    if webhook:
+        # 脱敏展示webhook（隐藏key的后半部分）
+        parsed = urlparse(webhook)
+        query = parse_qs(parsed.query)
+        if 'key' in query and query['key'][0]:
+            key = query['key'][0]
+            masked_key = key[:8] + "****" if len(key) > 8 else key + "****"
+            query['key'] = [masked_key]
+            masked_query = urlencode(query, doseq=True)
+            masked_webhook = urlunparse(
+                (parsed.scheme, parsed.netloc, parsed.path, parsed.params, masked_query, parsed.fragment))
+            SYLogger.info(f"自定义企业微信WebHook: {masked_webhook}")
+
+    # 初始化错误信息
+    error_info = None
+
+    try:
+        import uvicorn
+        # 执行启动（如果启动成功，此方法会阻塞，不会执行后续except）
+        uvicorn.run(*args, **kwargs)
+
+    except KeyboardInterrupt:
+        # 处理用户手动中断（不算启动失败）
+        elapsed = (datetime.now() - start_time).total_seconds()
+        SYLogger.info(f"\n{'='*50}")
+        SYLogger.info(f"ℹ️  应用被用户手动中断")
+        SYLogger.info(f"启动耗时: {elapsed:.2f} 秒")
+        SYLogger.info(f"{'='*50}\n")
+        sys.exit(0)
+
+    except Exception as e:
+        # 捕获启动失败异常，收集错误信息
+        elapsed = (datetime.now() - start_time).total_seconds()
+        # 捕获堆栈信息
+        stack_trace = traceback.format_exc()
+
+        # 构造错误信息字典
+        error_info = {
+            "error_type": type(e).__name__,
+            "error_msg": str(e),
+            "stack_trace": stack_trace,
+            "elapsed_time": elapsed
+        }
+
+        # 打印错误信息
+        SYLogger.info(f"\n{'='*50}")
+        SYLogger.info(f"🚨 应用启动失败！")
+        SYLogger.info(f"失败时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        SYLogger.info(f"错误类型: {type(e).__name__}")
+        SYLogger.info(f"错误信息: {str(e)}")
+        SYLogger.info(f"\n📝 错误堆栈（关键）:")
+        SYLogger.info(f"-"*50)
+        traceback.print_exc(file=sys.stdout)
+        SYLogger.info(f"\n⏱️  启动耗时: {elapsed:.2f} 秒")
+        SYLogger.info(f"{'='*50}\n")
+
+    finally:
+        # 运行异步通知函数，传递自定义的webhook参数
+        try:
+            asyncio.run(send_webhook(
+                error_info=error_info,
+                webhook=webhook
+            ))
+        except Exception as e:
+            SYLogger.info(f"错误：异步通知失败 - {str(e)}")
+        # 启动失败时退出程序
+        sys.exit(1)
+
+
+# 兼容旧调用方式（可选）
+run_uvicorn_with_monitor = run