infomankit 0.3.23__py3-none-any.whl

infoman/performance/runner.py

@@ -0,0 +1,303 @@
+"""
+性能测试运行器
+
+执行性能测试并收集结果
+"""
+
+import asyncio
+import time
+import statistics
+from typing import List, Dict, Any
+from dataclasses import dataclass, field
+from datetime import datetime
+import httpx
+from loguru import logger
+
+from .config import TestConfig, APITestCase
+from .standards import PerformanceStandards, StandardLevel
+
+
+@dataclass
+class TestResult:
+    """单次测试结果"""
+    test_case_name: str
+    url: str
+    method: str
+    status_code: int
+    response_time: float  # 毫秒
+    success: bool
+    error_message: str = ""
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class AggregatedResult:
+    """聚合测试结果"""
+    test_case_name: str
+    url: str
+    method: str
+    interface_type: str
+
+    # 请求统计
+    total_requests: int = 0
+    successful_requests: int = 0
+    failed_requests: int = 0
+    success_rate: float = 0.0
+
+    # 响应时间统计 (毫秒)
+    min_response_time: float = 0.0
+    max_response_time: float = 0.0
+    avg_response_time: float = 0.0
+    median_response_time: float = 0.0
+    p50_response_time: float = 0.0
+    p95_response_time: float = 0.0
+    p99_response_time: float = 0.0
+
+    # 吞吐量 (requests/second)
+    throughput: float = 0.0
+
+    # 性能评级
+    response_time_level: StandardLevel = StandardLevel.ACCEPTABLE
+    throughput_level: StandardLevel = StandardLevel.ACCEPTABLE
+    success_rate_level: StandardLevel = StandardLevel.ACCEPTABLE
+    overall_level: StandardLevel = StandardLevel.ACCEPTABLE
+
+    # 错误信息
+    error_messages: List[str] = field(default_factory=list)
+
+
+class PerformanceTestRunner:
+    """性能测试运行器"""
+
+    def __init__(self, config: TestConfig):
+        self.config = config
+        self.results: Dict[str, List[TestResult]] = {}
+        self.start_time: float = 0
+        self.end_time: float = 0
+
+    async def run(self) -> Dict[str, AggregatedResult]:
+        """
+        运行性能测试
+
+        Returns:
+            聚合结果字典 {test_case_name: AggregatedResult}
+        """
+        logger.info(f"🚀 开始性能测试: {self.config.project_name}")
+        logger.info(f"   并发用户: {self.config.concurrent_users}")
+        logger.info(f"   持续时间: {self.config.duration}秒")
+        logger.info(f"   测试用例: {len(self.config.get_enabled_test_cases())}个")
+
+        self.start_time = time.time()
+
+        # 创建并发任务
+        tasks = []
+        for i in range(self.config.concurrent_users):
+            task = asyncio.create_task(self._user_task(i))
+            tasks.append(task)
+            # 控制启动速率
+            await asyncio.sleep(1 / self.config.spawn_rate)
+
+        # 等待所有任务完成
+        await asyncio.gather(*tasks, return_exceptions=True)
+
+        self.end_time = time.time()
+
+        logger.success(f"✅ 性能测试完成，耗时: {self.end_time - self.start_time:.2f}秒")
+
+        # 聚合结果
+        aggregated = self._aggregate_results()
+
+        return aggregated
+
+    async def _user_task(self, user_id: int):
+        """单个用户的测试任务"""
+        test_cases = self.config.get_enabled_test_cases()
+        if not test_cases:
+            logger.warning("没有启用的测试用例")
+            return
+
+        end_time = self.start_time + self.config.duration
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            while time.time() < end_time:
+                # 依次执行所有测试用例
+                for test_case in test_cases:
+                    if time.time() >= end_time:
+                        break
+
+                    result = await self._execute_test_case(client, test_case)
+
+                    # 保存结果
+                    if test_case.name not in self.results:
+                        self.results[test_case.name] = []
+                    self.results[test_case.name].append(result)
+
+                    # 思考时间
+                    think_time = (
+                        self.config.think_time_min +
+                        (self.config.think_time_max - self.config.think_time_min) * 0.5
+                    )
+                    await asyncio.sleep(think_time)
+
+    async def _execute_test_case(
+        self,
+        client: httpx.AsyncClient,
+        test_case: APITestCase
+    ) -> TestResult:
+        """执行单个测试用例"""
+        url = self._build_url(test_case.url)
+
+        # 构建请求头
+        headers = {**self.config.global_headers, **test_case.headers}
+
+        # 添加认证
+        if self.config.auth_type == "bearer" and self.config.auth_token:
+            headers["Authorization"] = f"Bearer {self.config.auth_token}"
+
+        start_time = time.time()
+        success = False
+        status_code = 0
+        error_message = ""
+
+        try:
+            response = await client.request(
+                method=test_case.method,
+                url=url,
+                headers=headers,
+                params=test_case.params,
+                json=test_case.json,
+                data=test_case.data,
+                timeout=test_case.timeout,
+            )
+
+            status_code = response.status_code
+            success = 200 <= status_code < 300
+
+            if not success:
+                error_message = f"HTTP {status_code}: {response.text[:200]}"
+
+        except httpx.TimeoutException:
+            error_message = "请求超时"
+        except httpx.ConnectError:
+            error_message = "连接失败"
+        except Exception as e:
+            error_message = str(e)
+
+        end_time = time.time()
+        response_time = (end_time - start_time) * 1000  # 转换为毫秒
+
+        return TestResult(
+            test_case_name=test_case.name,
+            url=url,
+            method=test_case.method,
+            status_code=status_code,
+            response_time=response_time,
+            success=success,
+            error_message=error_message,
+        )
+
+    def _build_url(self, path: str) -> str:
+        """构建完整 URL"""
+        if path.startswith("http://") or path.startswith("https://"):
+            return path
+
+        base_url = self.config.base_url.rstrip("/")
+        path = path.lstrip("/")
+        return f"{base_url}/{path}"
+
+    def _aggregate_results(self) -> Dict[str, AggregatedResult]:
+        """聚合测试结果"""
+        aggregated = {}
+        test_duration = self.end_time - self.start_time
+
+        for test_case_name, results in self.results.items():
+            if not results:
+                continue
+
+            # 找到对应的测试用例配置
+            test_case = next(
+                (tc for tc in self.config.test_cases if tc.name == test_case_name),
+                None
+            )
+            interface_type = test_case.interface_type if test_case else "normal"
+
+            # 基本统计
+            total = len(results)
+            successful = sum(1 for r in results if r.success)
+            failed = total - successful
+            success_rate = (successful / total * 100) if total > 0 else 0
+
+            # 响应时间统计
+            response_times = [r.response_time for r in results]
+            response_times.sort()
+
+            min_rt = min(response_times) if response_times else 0
+            max_rt = max(response_times) if response_times else 0
+            avg_rt = statistics.mean(response_times) if response_times else 0
+            median_rt = statistics.median(response_times) if response_times else 0
+
+            # 百分位
+            p50 = self._percentile(response_times, 0.50)
+            p95 = self._percentile(response_times, 0.95)
+            p99 = self._percentile(response_times, 0.99)
+
+            # 吞吐量
+            throughput = total / test_duration if test_duration > 0 else 0
+
+            # 性能评级
+            rt_level = PerformanceStandards.evaluate_response_time(
+                avg_rt, interface_type
+            )
+            tp_level = PerformanceStandards.evaluate_throughput(
+                throughput, interface_type
+            )
+            sr_level = PerformanceStandards.evaluate_success_rate(success_rate)
+
+            # 综合评级 (取最差的)
+            overall_level = max(
+                [rt_level, tp_level, sr_level],
+                key=lambda x: list(StandardLevel).index(x)
+            )
+
+            # 错误信息
+            error_messages = [
+                r.error_message
+                for r in results
+                if not r.success and r.error_message
+            ]
+            unique_errors = list(set(error_messages))[:10]  # 最多10条
+
+            aggregated[test_case_name] = AggregatedResult(
+                test_case_name=test_case_name,
+                url=results[0].url,
+                method=results[0].method,
+                interface_type=interface_type,
+                total_requests=total,
+                successful_requests=successful,
+                failed_requests=failed,
+                success_rate=success_rate,
+                min_response_time=min_rt,
+                max_response_time=max_rt,
+                avg_response_time=avg_rt,
+                median_response_time=median_rt,
+                p50_response_time=p50,
+                p95_response_time=p95,
+                p99_response_time=p99,
+                throughput=throughput,
+                response_time_level=rt_level,
+                throughput_level=tp_level,
+                success_rate_level=sr_level,
+                overall_level=overall_level,
+                error_messages=unique_errors,
+            )
+
+        return aggregated
+
+    @staticmethod
+    def _percentile(data: List[float], percentile: float) -> float:
+        """计算百分位数"""
+        if not data:
+            return 0
+        sorted_data = sorted(data)
+        index = int(len(sorted_data) * percentile)
+        return sorted_data[min(index, len(sorted_data) - 1)]

infoman/performance/standards.py

@@ -0,0 +1,222 @@
+"""
+性能测试标准定义
+
+定义不同级别的性能标准，用于评估接口性能
+"""
+
+from enum import Enum
+from typing import Dict, Optional
+from dataclasses import dataclass
+
+
+class StandardLevel(str, Enum):
+    """标准级别"""
+    EXCELLENT = "excellent"    # 优秀
+    GOOD = "good"             # 良好
+    ACCEPTABLE = "acceptable" # 可接受
+    POOR = "poor"            # 较差
+    CRITICAL = "critical"    # 严重
+
+
+@dataclass
+class PerformanceThreshold:
+    """性能阈值"""
+    excellent: float  # 优秀阈值
+    good: float      # 良好阈值
+    acceptable: float # 可接受阈值
+    poor: float      # 较差阈值
+    # 超过 poor 即为 critical
+
+
+class PerformanceStandards:
+    """
+    性能测试标准
+
+    定义了不同类型接口的性能标准
+    """
+
+    # 标准定义 (单位: 毫秒)
+    STANDARDS = {
+        # 快速接口 (如健康检查、静态资源)
+        "fast": PerformanceThreshold(
+            excellent=10,    # < 10ms
+            good=30,        # < 30ms
+            acceptable=50,  # < 50ms
+            poor=100,       # < 100ms
+        ),
+
+        # 一般接口 (如简单查询、列表)
+        "normal": PerformanceThreshold(
+            excellent=50,    # < 50ms
+            good=100,       # < 100ms
+            acceptable=200, # < 200ms
+            poor=500,       # < 500ms
+        ),
+
+        # 复杂接口 (如复杂查询、聚合)
+        "complex": PerformanceThreshold(
+            excellent=100,   # < 100ms
+            good=200,       # < 200ms
+            acceptable=500, # < 500ms
+            poor=1000,      # < 1s
+        ),
+
+        # 重型接口 (如文件处理、批量操作)
+        "heavy": PerformanceThreshold(
+            excellent=200,   # < 200ms
+            good=500,       # < 500ms
+            acceptable=1000, # < 1s
+            poor=3000,      # < 3s
+        ),
+    }
+
+    # 吞吐量标准 (requests/second)
+    THROUGHPUT_STANDARDS = {
+        "fast": {
+            "excellent": 1000,
+            "good": 500,
+            "acceptable": 200,
+            "poor": 100,
+        },
+        "normal": {
+            "excellent": 500,
+            "good": 200,
+            "acceptable": 100,
+            "poor": 50,
+        },
+        "complex": {
+            "excellent": 200,
+            "good": 100,
+            "acceptable": 50,
+            "poor": 20,
+        },
+        "heavy": {
+            "excellent": 100,
+            "good": 50,
+            "acceptable": 20,
+            "poor": 10,
+        },
+    }
+
+    # 并发用户标准
+    CONCURRENCY_STANDARDS = {
+        "low": 10,      # 低并发
+        "medium": 50,   # 中并发
+        "high": 100,    # 高并发
+        "extreme": 500, # 极限并发
+    }
+
+    # 成功率标准
+    SUCCESS_RATE_STANDARDS = {
+        "excellent": 99.9,   # 99.9%
+        "good": 99.0,       # 99%
+        "acceptable": 95.0, # 95%
+        "poor": 90.0,       # 90%
+    }
+
+    @classmethod
+    def evaluate_response_time(
+        cls,
+        response_time: float,
+        interface_type: str = "normal"
+    ) -> StandardLevel:
+        """
+        评估响应时间
+
+        Args:
+            response_time: 响应时间 (毫秒)
+            interface_type: 接口类型 (fast/normal/complex/heavy)
+
+        Returns:
+            标准级别
+        """
+        threshold = cls.STANDARDS.get(interface_type, cls.STANDARDS["normal"])
+
+        if response_time <= threshold.excellent:
+            return StandardLevel.EXCELLENT
+        elif response_time <= threshold.good:
+            return StandardLevel.GOOD
+        elif response_time <= threshold.acceptable:
+            return StandardLevel.ACCEPTABLE
+        elif response_time <= threshold.poor:
+            return StandardLevel.POOR
+        else:
+            return StandardLevel.CRITICAL
+
+    @classmethod
+    def evaluate_throughput(
+        cls,
+        throughput: float,
+        interface_type: str = "normal"
+    ) -> StandardLevel:
+        """评估吞吐量"""
+        standards = cls.THROUGHPUT_STANDARDS.get(
+            interface_type,
+            cls.THROUGHPUT_STANDARDS["normal"]
+        )
+
+        if throughput >= standards["excellent"]:
+            return StandardLevel.EXCELLENT
+        elif throughput >= standards["good"]:
+            return StandardLevel.GOOD
+        elif throughput >= standards["acceptable"]:
+            return StandardLevel.ACCEPTABLE
+        elif throughput >= standards["poor"]:
+            return StandardLevel.POOR
+        else:
+            return StandardLevel.CRITICAL
+
+    @classmethod
+    def evaluate_success_rate(cls, success_rate: float) -> StandardLevel:
+        """评估成功率"""
+        if success_rate >= cls.SUCCESS_RATE_STANDARDS["excellent"]:
+            return StandardLevel.EXCELLENT
+        elif success_rate >= cls.SUCCESS_RATE_STANDARDS["good"]:
+            return StandardLevel.GOOD
+        elif success_rate >= cls.SUCCESS_RATE_STANDARDS["acceptable"]:
+            return StandardLevel.ACCEPTABLE
+        elif success_rate >= cls.SUCCESS_RATE_STANDARDS["poor"]:
+            return StandardLevel.POOR
+        else:
+            return StandardLevel.CRITICAL
+
+    @classmethod
+    def get_threshold(cls, interface_type: str = "normal") -> PerformanceThreshold:
+        """获取性能阈值"""
+        return cls.STANDARDS.get(interface_type, cls.STANDARDS["normal"])
+
+    @classmethod
+    def get_level_color(cls, level: StandardLevel) -> str:
+        """获取级别对应的颜色"""
+        colors = {
+            StandardLevel.EXCELLENT: "#10b981",  # 绿色
+            StandardLevel.GOOD: "#3b82f6",      # 蓝色
+            StandardLevel.ACCEPTABLE: "#f59e0b", # 橙色
+            StandardLevel.POOR: "#ef4444",      # 红色
+            StandardLevel.CRITICAL: "#991b1b",  # 深红色
+        }
+        return colors.get(level, "#6b7280")
+
+    @classmethod
+    def get_level_label(cls, level: StandardLevel) -> str:
+        """获取级别标签 (中文)"""
+        labels = {
+            StandardLevel.EXCELLENT: "优秀",
+            StandardLevel.GOOD: "良好",
+            StandardLevel.ACCEPTABLE: "可接受",
+            StandardLevel.POOR: "较差",
+            StandardLevel.CRITICAL: "严重",
+        }
+        return labels.get(level, "未知")
+
+    @classmethod
+    def get_recommendation(cls, level: StandardLevel) -> str:
+        """获取优化建议"""
+        recommendations = {
+            StandardLevel.EXCELLENT: "性能优异，继续保持",
+            StandardLevel.GOOD: "性能良好，可考虑进一步优化",
+            StandardLevel.ACCEPTABLE: "性能可接受，建议优化以提升用户体验",
+            StandardLevel.POOR: "性能较差，建议优先优化此接口",
+            StandardLevel.CRITICAL: "性能严重不足，需要立即优化",
+        }
+        return recommendations.get(level, "")

infoman/service/__init__.py

@@ -0,0 +1,8 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2025/6/21 19:59
+# Author     ：Maxwell
+# Description：
+"""

infoman/service/app.py

@@ -0,0 +1,67 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+from infoman.config.settings import settings
+from infoman.logger import setup_logger
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.gzip import GZipMiddleware
+from infoman.service.middleware.logging import LoggingMiddleware
+from infoman.service.middleware.request_id import RequestIDMiddleware
+from infoman.service.routers import api_router
+from infoman.config.settings import settings as config
+from infoman.service.core.response import ProRJSONResponse
+from infoman.service.core.monitor import instrumentator
+from infoman.service.core.lifespan import lifespan
+from infoman.service.exception.handler import register_exception_handlers
+
+# ============ 日志配置 ============
+setup_logger()
+
+# ============ 创建 FastAPI 应用实例 ============
+application = FastAPI(
+    title=config.APP_NAME,
+    docs_url=config.DOCS_URL,
+    redoc_url=config.APP_REDOC_URL,
+    description=config.APP_DESCRIPTION,
+    default_response_class=ProRJSONResponse,
+    lifespan=lifespan
+)
+
+# ============ 异常处理器 ============
+register_exception_handlers(application)
+
+# ============ 中间件（添加顺序和执行顺序相反-洋葱模型） ============
+application.add_middleware(GZipMiddleware, minimum_size=1000)
+application.add_middleware(
+    CORSMiddleware,
+    allow_origins=config.ALLOW_ORIGINS,
+    allow_credentials=config.ALLOW_CREDENTIALS,
+    allow_methods=config.ALLOW_METHODS,
+    allow_headers=config.ALLOW_HEADERS,
+    max_age=config.MAX_AGE,
+)
+application.add_middleware(RequestIDMiddleware)
+application.add_middleware(LoggingMiddleware)
+
+# ============ 内置路由（可选，用户可以选择不使用） ============
+if config.USE_DEFAULT_ROUTER:
+    application.include_router(api_router)
+
+if config.USE_TEMPLATES:
+    from fastapi.templating import Jinja2Templates
+    application.state.templates = Jinja2Templates(directory=config.TEMPLATE_DIR)
+
+if config.USE_STATIC:
+    from fastapi.staticfiles import StaticFiles
+    application.mount(
+        path=config.STATIC_URL,
+        app=StaticFiles(directory=config.STATIC_DIR),
+        name=config.STATIC_NAME
+    )
+
+# ============ Prometheus 监控 ============
+if config.USE_PROMETHEUS_ROUTER:
+    instrumentator.instrument(application).expose(application, endpoint="/metrics")
+
+

infoman/service/core/auth.py

@@ -0,0 +1,105 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2025/6/21 23:21
+# Author     ：Maxwell
+# Description：
+"""
+import jwt
+from datetime import timedelta, datetime
+from enum import Enum
+from typing import Optional, Dict, Any, TypeVar
+
+from fastapi import Request, Depends
+from fastapi.security.oauth2 import OAuth2PasswordBearer
+from jwt import PyJWTError
+from pydantic import ValidationError, BaseModel
+
+from infoman.config import settings as config
+from infoman.service.exception import exception
+from infoman.service.exception import error
+
+T = TypeVar("T")
+
+
+class SecurityConstants:
+    REDIS_USER_KEY_PREFIX = "U_API_AUTH_KEY_"
+    REDIS_OPEN_API_KEY_PREFIX = "O_API_AUTH_KEY_"
+    REDIS_CACHE_EXPIRE = 3 * 3600
+
+
+class TokenPayload(BaseModel):
+    exp: Optional[datetime] = None
+    user_id: Optional[int] = None
+
+
+class TokenType(str, Enum):
+    ACCESS = "access"
+    REFRESH = "refresh"
+    OPEN_API = "open_api"
+
+
+class JWTHandler:
+
+    @staticmethod
+    def create_token(
+        data: Dict[str, Any],
+        expires_delta: Optional[timedelta] = None,
+        token_type: TokenType = TokenType.ACCESS,
+    ) -> str:
+        payload = data.copy()
+        if expires_delta:
+            expire = datetime.utcnow() + expires_delta
+        elif token_type == TokenType.ACCESS:
+            expire = datetime.utcnow() + timedelta(
+                minutes=config.JWT_ACCESS_TOKEN_EXPIRE_MINUTES
+            )
+        else:
+            expire = datetime.utcnow() + timedelta(days=365)
+        payload.update({"exp": expire, "token_type": token_type})
+        return jwt.encode(
+            payload, config.JWT_SECRET_KEY, algorithm=config.JWT_ALGORITHM
+        )
+
+    @staticmethod
+    def decode_token(token: str) -> Dict[str, Any]:
+        try:
+            payload = jwt.decode(
+                token, config.JWT_SECRET_KEY, algorithms=[config.JWT_ALGORITHM]
+            )
+            return payload
+        except jwt.ExpiredSignatureError:
+            raise exception.AppException(error.SecurityError.TOKEN_EXPIRED)
+        except (jwt.InvalidTokenError, PyJWTError, ValidationError):
+            raise exception.AppException(error.SecurityError.INVALID_CREDENTIALS)
+
+    @staticmethod
+    def verify_token(token: str) -> TokenPayload:
+        try:
+            payload = JWTHandler.decode_token(token)
+            token_data = TokenPayload(**payload)
+            if token_data.exp and token_data.exp < datetime.utcnow():
+                raise exception.AppException(error.SecurityError.TOKEN_EXPIRED)
+            return token_data
+        except ValidationError:
+            raise exception.AppException(error.SecurityError.INVALID_TOKEN)
+
+
+class TokenExtractor:
+
+    @staticmethod
+    def get_user_id(token: str) -> Optional[int]:
+        try:
+            payload = JWTHandler.decode_token(token)
+            return payload.get("user_id")
+        except Exception:
+            return None
+
+    @staticmethod
+    def get_open_user_id(token: str) -> Optional[int]:
+        try:
+            payload = JWTHandler.decode_token(token)
+            return payload.get("open_user_id")
+        except Exception:
+            return None