cancan-microstack 0.0.1__py3-none-any.whl

cancan_microstack/services/opsbffsrv/infrastructure/db/operate/service_registry.py

@@ -0,0 +1,138 @@
+"""opsbffsrv service registry data access."""
+from typing import (
+    List,
+    Optional,
+)
+
+from sqlalchemy import select, and_
+
+from linglong_web import Rmanager
+from cancan_microstack.public.schemas.infra.enums import ServiceType
+from cancan_microstack.public.schemas.infra.service_info import ServiceInfo
+from cancan_microstack.public.schemas.infra.service_registry import ServiceMetadata
+from cancan_microstack.public.schemas.infra.service_instance import ServiceInstance
+from cancan_microstack.services.opsbffsrv.infrastructure.db.model.service_info_tbl import ServiceInfoTbl
+from cancan_microstack.services.opsbffsrv.infrastructure.db.model.service_instance_tbl import ServiceInstanceTbl
+
+
+def _service_info_to_metadata(row: ServiceInfoTbl) -> ServiceMetadata:
+    """将 ServiceInfo ORM 记录转换为 ServiceMetadata / Orchestrate metadata view."""
+
+    data = ServiceInfo.model_validate(row, from_attributes=True)
+    metadata_bag = dict(data.service_metadata or {})
+    owner = metadata_bag.get("owner")
+    deploy_region = metadata_bag.get("deploy_region")
+    config_version = metadata_bag.get("config_version")
+
+    service_type = data.service_type
+    if not isinstance(service_type, ServiceType):
+        service_type = ServiceType(service_type)
+
+    return ServiceMetadata(
+        service_name=data.service_name,
+        description=data.description,
+        service_type=service_type,
+        owner=owner,
+        health_check_path=data.health_check_path,
+        deploy_region=deploy_region,
+        config_version=config_version,
+        service_metadata=metadata_bag,
+        expected_status=data.expected_status,
+        desired_replicas=data.desired_replicas,
+        actual_replicas=data.actual_replicas,
+        last_scale_at=data.last_scale_at,
+        scale_policy=data.scale_policy,
+        registered_time=data.registered_time,
+        last_registered_time=data.last_registered_time,
+        created_time=data.created_time,
+        update_time=data.update_time,
+    )
+
+
+async def get_service_metadata(service_name: str) -> Optional[ServiceMetadata]:
+    """获取指定服务的元数据 / Fetch metadata for a single service."""
+
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceInfoTbl).where(
+                and_(
+                    ServiceInfoTbl.service_name == service_name,
+                    ServiceInfoTbl.flag == 0,
+                )
+            )
+            row = (await session.execute(stmt)).scalar_one_or_none()
+            return _service_info_to_metadata(row) if row else None
+
+
+async def get_service_instances(
+        service_name: str,
+        status: Optional[str] = None,
+    health_status: Optional[str] = None,
+) -> List[ServiceInstance]:
+    """获取指定服务的实例列表 / Fetch instances for a single service."""
+
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceInstanceTbl).where(
+                and_(
+                    ServiceInstanceTbl.service_name == service_name,
+                    ServiceInstanceTbl.flag == 0,
+                )
+            )
+            if status:
+                stmt = stmt.where(ServiceInstanceTbl.status == status)
+            if health_status:
+                stmt = stmt.where(ServiceInstanceTbl.health_status == health_status)
+
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [ServiceInstance.model_validate(r, from_attributes=True) for r in rows]
+
+
+async def get_service_by_instance(
+        service_name: str,
+        instance_id: str,
+) -> Optional[ServiceInstance]:
+    """根据服务名 + 实例ID 查询单条实例 / Fetch a concrete instance row."""
+
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceInstanceTbl).where(
+                and_(
+                    ServiceInstanceTbl.service_name == service_name,
+                    ServiceInstanceTbl.instance_id == instance_id,
+                    ServiceInstanceTbl.flag == 0,
+                )
+            )
+            row = (await session.execute(stmt)).scalar_one_or_none()
+            return ServiceInstance.model_validate(row, from_attributes=True) if row else None
+
+
+async def get_all_services() -> List[ServiceInstance]:
+    """列出全部服务实例 / List every active service instance."""
+
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceInstanceTbl).where(ServiceInstanceTbl.flag == 0)
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [ServiceInstance.model_validate(r, from_attributes=True) for r in rows]
+
+
+async def get_all_service_names() -> List[str]:
+    """获取所有服务名称 / Fetch distinct service names."""
+
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceInfoTbl.service_name).where(ServiceInfoTbl.flag == 0).order_by(
+                ServiceInfoTbl.service_name.asc())
+            rows = (await session.execute(stmt)).scalars().all()
+            return list(rows) if rows else []
+
+
+async def list_service_metadata() -> List[ServiceMetadata]:
+    """列出服务级元数据 / Return service metadata rows."""
+
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceInfoTbl).where(ServiceInfoTbl.flag == 0)
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [_service_info_to_metadata(r) for r in rows]

cancan_microstack/services/opsbffsrv/infrastructure/ddl_manager.py

@@ -0,0 +1,31 @@
+"""OpsBffSrv DDL 管理入口
+OpsBffSrv entry point wiring the shared AutoDDLManager with service config.
+"""
+from pathlib import Path
+
+from linglong_web import (
+    AutoDDLManager,
+    DDLManagerConfig,
+    LinglongConfig,
+)
+
+from cancan_microstack.runtime.resources import resolve_workspace_or_asset
+
+
+def _build_manager() -> AutoDDLManager:
+    """构建通用 DDL 管理器实例 / Build service-specific AutoDDLManager"""
+
+    trigger_file = resolve_workspace_or_asset("ddl/trigger.sql", "ddl/trigger.sql")
+
+    config = DDLManagerConfig(
+        script_path=Path(LinglongConfig.DDL_SCRIPT_PATH),
+        enable_auto_init=LinglongConfig.ENABLE_DDL_AUTO_INIT,
+        trigger_sql_paths=(trigger_file,),
+        abort_on_trigger_failure=True,
+    )
+    return AutoDDLManager(config)
+
+
+async def init_ddl() -> bool:
+    """初始化 DDL（供 AppServer 调用）/ Trigger schema auto-initialization"""
+    return await _build_manager().check_and_init_tables()

cancan_microstack/services/opsbffsrv/infrastructure/mongo/__init__.py

@@ -0,0 +1 @@
+"""opsbffsrv Mongo infrastructure package."""

cancan_microstack/services/opsbffsrv/infrastructure/mongo/log_query_repository.py

@@ -0,0 +1,87 @@
+"""MongoDB 日志查询仓库 / Mongo-backed log query repository."""
+import asyncio
+from typing import (
+    Any,
+    Dict,
+    List,
+    Tuple,
+)
+
+from pymongo.asynchronous.collection import AsyncCollection
+from pymongo import DESCENDING
+
+from cancan_microstack.public.schemas.logging.log_event import LogEventDocument
+from linglong_web import LinglongConfig
+from linglong_web import Rmanager
+from linglong_web.utils import logger
+
+
+class LogQueryRepository:
+    """封装日志查询操作 / Encapsulate log query operations."""
+
+    def __init__(self) -> None:
+        """
+        Initializes the repository using the global MongoDB client.
+        """
+        # 注意：不能在 __init__ 时缓存 Rmanager.MongoClient。
+        # Note: Do NOT cache Rmanager.MongoClient at __init__ time.
+        #
+        # 说明 / Rationale:
+        # - 该 Repository 可能在模块 import 阶段被创建（全局单例）。
+        #   It may be instantiated at import time (module-level singleton).
+        # - 资源初始化（init_resources）发生在服务启动生命周期更靠后的位置。
+        #   Resource initialization happens later in the server lifecycle.
+        # - 如果这里缓存了 None，会导致整个进程里一直拿不到 Mongo client。
+        #   Caching None here makes Mongo client unavailable forever.
+        self._collection: AsyncCollection | None = None
+        self._init_lock = asyncio.Lock()
+
+    async def _get_collection(self) -> AsyncCollection:
+        """Lazily initializes and returns the MongoDB collection object."""
+        if self._collection is not None:
+            return self._collection
+
+        async with self._init_lock:
+            if self._collection is not None:
+                return self._collection
+
+            client = Rmanager.MongoClient
+            if not client:
+                raise RuntimeError("MongoDB client is not available in Rmanager.")
+
+            db_name = LinglongConfig.MONGODB_DB
+            collection_name = LinglongConfig.MONGODB_COLLECTION
+            if not db_name or not collection_name:
+                raise RuntimeError(
+                    "MongoDB config is not available: MONGODB_DB/MONGODB_COLLECTION is empty."
+                )
+
+            collection = client[db_name][collection_name]
+            self._collection = collection
+            logger.info(
+                "LogQueryRepository collection '%s/%s' initialized.", db_name, collection_name
+            )
+            return self._collection
+
+    async def query_logs(
+            self,
+            filters: Dict[str, Any],
+            skip: int,
+            limit: int,
+    ) -> Tuple[List[LogEventDocument], int]:
+        collection = await self._get_collection()
+        cursor = (
+            collection.find(filters)
+            .sort("timestamp", DESCENDING)
+            .skip(skip)
+            .limit(limit)
+        )
+        raw_docs = await cursor.to_list(length=limit)
+        events = [self._convert_document(doc) for doc in raw_docs]
+        total = await collection.count_documents(filters)
+        return events, int(total)
+
+    def _convert_document(self, doc: Dict[str, Any]) -> LogEventDocument:
+        doc = dict(doc)
+        doc.pop("_id", None)
+        return LogEventDocument.model_validate(doc)

cancan_microstack/services/opsbffsrv/interface/api/async_operation_api.py

@@ -0,0 +1,137 @@
+"""
+异步操作管理 API
+
+为前端提供异步操作管理接口：
+1. 异步启动/停止/重启/扩缩容/重建服务（立即返回 operation_id）
+2. 查询操作状态
+3. 列出操作历史
+
+架构说明：
+- opsbffsrv: 生成 operation_id，管理操作记录（通过 infrasrv），协调异步执行
+- controllersrv: 纯粹的 Docker 命令执行器，同步返回结果
+- infrasrv: 存储操作记录，提供查询接口
+"""
+from typing import (
+    Optional,
+)
+import http
+
+from pydantic import (
+    BaseModel,
+    Field,
+)
+
+from cancan_microstack.public.const.error import ErrorCode
+from linglong_web import LinglongHTTPException
+from cancan_microstack.public.const.operation_consts import (
+    OperationType,
+    InitiatedBy,
+    InitiatedFrom,
+)
+from cancan_microstack.public.schemas.common import (
+    APIResponse,
+)
+from cancan_microstack.public.schemas.infra.operation import (
+    OperationResponse,
+    OperationListResponse,
+)
+from cancan_microstack.public.schemas.opsbffsrv.async_ops import AsyncOperationResponse
+from linglong_web import (
+    build_success_response,
+)
+from cancan_microstack.services.opsbffsrv.application.async_operation_app import AsyncOperationApp
+from cancan_microstack.services.opsbffsrv.infrastructure.api.infrasrv_api import InfraSrvApi
+from linglong_web.utils import logger
+
+# 应用层和基础设施层实例
+_async_op_app = AsyncOperationApp()
+_infrasrv_api = InfraSrvApi()
+
+
+class AsyncOperationRequest(BaseModel):
+    """异步操作请求模型"""
+    service_name: str = Field(..., description="服务名称（不带 .service 后缀）")
+    operation_params: dict = Field(default_factory=dict, description="操作参数")
+    initiated_by: InitiatedBy = Field(default=InitiatedBy.OPSBFFSRV, description="操作发起者")
+
+
+async def async_start_service_handler(
+        request: AsyncOperationRequest,
+) -> APIResponse[AsyncOperationResponse]:
+    """异步启动服务"""
+    logger.info(f"Async start service: {request.service_name}")
+    result = await _async_op_app.submit_operation(
+        operation_type=OperationType.START,
+        service_name=request.service_name,
+        operation_params=request.operation_params,
+        initiated_by=request.initiated_by,
+        initiated_from=InitiatedFrom.FRONTEND
+    )
+    return build_success_response(data=result)
+
+
+async def async_stop_service_handler(
+        request: AsyncOperationRequest,
+) -> APIResponse[AsyncOperationResponse]:
+    """异步停止服务"""
+    logger.info(f"Async stop service: {request.service_name}")
+    result = await _async_op_app.submit_operation(
+        operation_type=OperationType.STOP,
+        service_name=request.service_name,
+        operation_params=request.operation_params,
+        initiated_by=request.initiated_by,
+        initiated_from=InitiatedFrom.FRONTEND
+    )
+    return build_success_response(data=result)
+
+
+async def async_restart_service_handler(
+        request: AsyncOperationRequest,
+) -> APIResponse[AsyncOperationResponse]:
+    """异步重启服务"""
+    logger.info(f"Async restart service: {request.service_name}")
+    result = await _async_op_app.submit_operation(
+        operation_type=OperationType.RESTART,
+        service_name=request.service_name,
+        operation_params=request.operation_params,
+        initiated_by=request.initiated_by,
+        initiated_from=InitiatedFrom.FRONTEND
+    )
+    return build_success_response(data=result)
+
+
+
+async def get_operation_status_handler(
+        operation_id: str,
+) -> APIResponse[OperationResponse]:
+    """查询操作状态"""
+    logger.debug(f"Query operation status: {operation_id}")
+    # 使用新的 get_operation 方法（基类中定义）
+    result = await _infrasrv_api.get_operation(operation_id)
+    if result.success and result.data is not None:
+        return build_success_response(data=result.data)
+
+    message = result.error.msg or "Failed to query operation status"
+    raise LinglongHTTPException(
+        status_code=http.HTTPStatus.INTERNAL_SERVER_ERROR.value,
+        error_code=result.error.code or ErrorCode.SYSTEM_ERROR,
+    )
+
+
+async def list_operations_handler(
+        service_name: Optional[str] = None,
+        status: Optional[str] = None,
+        limit: int = 50,
+        offset: int = 0
+) -> APIResponse[OperationListResponse]:
+    """列出操作历史"""
+    logger.debug(f"List operations: service={service_name}, status={status}")
+    result = await _infrasrv_api.list_operations(service_name, status, limit, offset)
+    if result.success and result.data is not None:
+        return build_success_response(data=result.data)
+
+    message = result.error.msg or "Failed to list operations"
+    raise LinglongHTTPException(
+        status_code=http.HTTPStatus.INTERNAL_SERVER_ERROR.value,
+        error_code=result.error.code or ErrorCode.SYSTEM_ERROR,
+    )

cancan_microstack/services/opsbffsrv/interface/api/auth_api.py

@@ -0,0 +1,113 @@
+"""认证 HTTP handler / Authentication API handlers."""
+import http
+
+from fastapi import Request, Response
+
+from linglong_web import build_success_response, LinglongConfig
+
+from cancan_microstack.public.const.opsbffsrv_error import OpsbffsrvAuthErrorCode
+from cancan_microstack.public.error import HTTPException
+from cancan_microstack.services.opsbffsrv.application import auth_app
+from cancan_microstack.services.opsbffsrv.application.auth_app import (
+    LoginRequest,
+    TempTokenRequest,
+    TotpCodeRequest,
+)
+
+
+def get_client_ip(request: Request) -> str:
+    """从 X-Forwarded-For → X-Real-IP → direct 依次读取真实客户端 IP。"""
+    forwarded = request.headers.get("X-Forwarded-For")
+    if forwarded:
+        return forwarded.split(",")[0].strip()
+    real_ip = request.headers.get("X-Real-IP")
+    if real_ip:
+        return real_ip.strip()
+    return request.client.host if request.client else "unknown"
+
+
+def _set_session_cookie(response: Response, token: str) -> None:
+    """设置 session Cookie / Set ops_session cookie on response."""
+    session_ttl = int(LinglongConfig.get("AUTH_SESSION_TTL", 86400))
+    cookie_secure = str(LinglongConfig.get("AUTH_COOKIE_SECURE", "true")).lower() == "true"
+    response.set_cookie(
+        key="ops_session",
+        value=token,
+        httponly=True,
+        secure=cookie_secure,
+        path="/",
+        max_age=session_ttl,
+        samesite="lax",
+    )
+
+
+async def get_captcha_handler():
+    """GET /v1/opsbffsrv/auth/captcha — 返回验证码图片"""
+    result = await auth_app.get_captcha()
+    return build_success_response(data=result)
+
+
+async def login_handler(request: Request, payload: LoginRequest):
+    """POST /v1/opsbffsrv/auth/login — 登录（用户名+密码+验证码）"""
+    client_ip = get_client_ip(request)
+    result = await auth_app.login(payload, client_ip)
+    return build_success_response(data=result)
+
+
+async def totp_setup_handler(payload: TempTokenRequest):
+    """POST /v1/opsbffsrv/auth/totp/setup — 获取 TOTP 绑定二维码"""
+    result = await auth_app.totp_setup(payload.temp_token)
+    return build_success_response(data=result)
+
+
+async def totp_bind_handler(response: Response, payload: TotpCodeRequest):
+    """POST /v1/opsbffsrv/auth/totp/bind — 完成 TOTP 绑定"""
+    session_token = await auth_app.totp_bind(payload.temp_token, payload.totp_code)
+    _set_session_cookie(response, session_token)
+    return build_success_response(data={"message": "TOTP bound successfully"})
+
+
+async def totp_verify_handler(response: Response, payload: TotpCodeRequest):
+    """POST /v1/opsbffsrv/auth/totp/verify — 常规 TOTP 验证"""
+    session_token = await auth_app.totp_verify(payload.temp_token, payload.totp_code)
+    _set_session_cookie(response, session_token)
+    return build_success_response(data={"message": "TOTP verified successfully"})
+
+
+async def logout_handler(request: Request, response: Response):
+    """POST /v1/opsbffsrv/auth/logout — 登出（撤销 Redis 会话 + 清除 cookie）"""
+    token = request.cookies.get("ops_session")
+    await auth_app.logout(token)
+    # 清除 cookie：复用 Secure 配置，max_age=0 让浏览器立即删除。
+    cookie_secure = str(getattr(LinglongConfig, "AUTH_COOKIE_SECURE", "true")).lower() == "true"
+    response.set_cookie(
+        key="ops_session",
+        value="",
+        httponly=True,
+        secure=cookie_secure,
+        path="/",
+        max_age=0,
+        samesite="lax",
+    )
+    return build_success_response(data={"message": "Logged out"})
+
+
+async def check_session_handler(request: Request):
+    """GET /v1/opsbffsrv/auth/session — 检查当前 session"""
+    token = request.cookies.get("ops_session")
+    if not token:
+        raise HTTPException(
+            status_code=http.HTTPStatus.UNAUTHORIZED.value,
+            error_code=OpsbffsrvAuthErrorCode.SESSION_INVALID,
+            msg="Not authenticated",
+        )
+
+    result = await auth_app.check_session(token)
+    if result is None:
+        raise HTTPException(
+            status_code=http.HTTPStatus.UNAUTHORIZED.value,
+            error_code=OpsbffsrvAuthErrorCode.SESSION_INVALID,
+            msg="Session expired",
+        )
+
+    return build_success_response(data=result)

cancan_microstack/services/opsbffsrv/interface/api/caddy/__init__.py

@@ -0,0 +1,3 @@
+"""
+Caddy API接口层包初始化
+"""

cancan_microstack/services/opsbffsrv/interface/api/caddy/access_log_api.py

@@ -0,0 +1,174 @@
+"""
+Caddy 访问日志 API 接口
+
+提供日志查询、安全事件监控、异常分析等功能
+"""
+from typing import (
+    Optional,
+)
+
+from linglong_web.utils import logger
+from cancan_microstack.public.schemas.common import APIResponse
+from linglong_web import build_success_response
+from linglong_web import limiter
+from cancan_microstack.public.schemas.caddy import AccessLogQuery
+from cancan_microstack.services.opsbffsrv.application.caddy.access_log_analysis_app import AccessLogAnalysisApp
+
+# 应用层实例
+_log_app = AccessLogAnalysisApp()
+
+
+@limiter("30/second")
+async def search_logs_handler(query: AccessLogQuery) -> APIResponse[dict]:
+    """
+    搜索访问日志
+    
+    Args:
+        query: 查询条件
+    
+    Returns:
+        统一响应格式
+    """
+    logger.info(f"搜索访问日志: service={query.service_name}, route_id={query.route_id}")
+    logs = await _log_app.search_logs(query)
+
+    return build_success_response(data={
+        "logs": [log.model_dump() for log in logs],
+        "total": len(logs),
+        "query": query.model_dump(),
+    })
+
+
+@limiter("20/second")
+async def get_security_events_handler(
+        event_type: str = "waf_blocked",
+        limit: int = 100,
+) -> APIResponse[dict]:
+    """
+    获取安全事件（WAF 拦截、限流触发）
+
+    Args:
+        event_type: 事件类型（waf_blocked / rate_limited）
+        limit: 返回数量
+
+    Returns:
+        统一响应格式
+    """
+    logger.info(f"获取安全事件: type={event_type}, limit={limit}")
+    # 应用层返回 dict 信封：{status, event_type, count, data:[CaddyAccessLog...]}
+    # 直接透传该信封，APIResponse 会自动序列化其中的 pydantic 模型。
+    result = await _log_app.get_security_events(event_type=event_type, limit=limit)
+
+    return build_success_response(data=result)
+
+
+@limiter("20/second")
+async def analyze_geographic_distribution_handler(
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+) -> APIResponse[dict]:
+    """
+    分析地理分布
+
+    Args:
+        start_time: 开始时间（ISO 8601格式）
+        end_time: 结束时间（ISO 8601格式）
+
+    Returns:
+        统一响应格式
+    """
+    logger.info("分析地理分布")
+    # 应用层返回 dict 信封：{status, data:[...]}，直接透传。
+    result = await _log_app.analyze_geographic_distribution(
+        start_time=start_time,
+        end_time=end_time
+    )
+
+    return build_success_response(data=result)
+
+
+@limiter("20/second")
+async def analyze_status_code_distribution_handler(
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+) -> APIResponse[dict]:
+    """
+    分析状态码分布
+
+    Args:
+        start_time: 开始时间（ISO 8601格式）
+        end_time: 结束时间（ISO 8601格式）
+
+    Returns:
+        统一响应格式
+    """
+    logger.info("分析状态码分布")
+    # 应用层返回 dict 信封：{status, data:[...]}，直接透传。
+    result = await _log_app.analyze_status_code_distribution(
+        start_time=start_time,
+        end_time=end_time
+    )
+
+    return build_success_response(data=result)
+
+
+@limiter("10/second")
+async def detect_suspicious_ips_handler(
+        threshold: int = 1000,
+        time_window_minutes: int = 10,
+) -> APIResponse[dict]:
+    """
+    检测可疑 IP（高频访问）
+    
+    Args:
+        threshold: 阈值（次数）
+        time_window_minutes: 时间窗口（分钟）
+    
+    Returns:
+        统一响应格式
+    """
+    logger.info(f"检测可疑IP: threshold={threshold}, window={time_window_minutes}min")
+    # 对齐应用层签名：detect_suspicious_ips(time_window, request_threshold)
+    # 应用层返回 dict 信封：{status, count, data:[SuspiciousIP...]}，直接透传。
+    result = await _log_app.detect_suspicious_ips(
+        time_window=time_window_minutes,
+        request_threshold=threshold,
+    )
+
+    return build_success_response(data=result)
+
+
+@limiter("20/second")
+async def analyze_error_patterns_handler(hours: int = 24) -> APIResponse[dict]:
+    """
+    分析错误模式（4xx/5xx）
+
+    Args:
+        hours: 分析过去多少小时的错误（默认 24 小时）
+
+    Returns:
+        统一响应格式
+    """
+    logger.info(f"分析错误模式: hours={hours}")
+    # 对齐应用层签名：analyze_error_patterns(hours)
+    # 应用层返回 dict 信封：{status, total_errors, error_rate, ...}，直接透传。
+    result = await _log_app.analyze_error_patterns(hours=hours)
+
+    return build_success_response(data=result)
+
+
+@limiter("5/second")
+async def cleanup_old_logs_handler(days: int = 30) -> APIResponse[dict | None]:
+    """
+    清理旧日志
+    
+    Args:
+        days: 保留天数（默认30天）
+    
+    Returns:
+        统一响应格式
+    """
+    logger.info(f"清理旧日志: days={days}")
+    result = await _log_app.cleanup_old_logs(days)
+
+    return build_success_response(data=result)