303 lines
11 KiB
Python
303 lines
11 KiB
Python
"""Alert 子域 Router。
|
||
|
||
外部系统限界上下文的告警事件管理 API，覆盖告警列表 / 详情 / 触发 /
|
||
确认 / 恢复 / 统计聚合 / 按链路查询 / 批量确认 / 批量恢复 / 告警上下文 /
|
||
通知状态。所有端点通过 ``create_use_cases_from_db`` 装配 use_cases，
|
||
经 ``alert_service`` 端口调用用例。
|
||
|
||
``list_alerts`` 支持 resource_type / resource_id / related_trace_id /
|
||
dedup_key 过滤参数。Request Schema 与 Input DTO 不共享类，Router 内显式
|
||
构造 DTO，确认 / 恢复操作的 ``acknowledged_by`` / ``user`` 字段由
|
||
``current_user.uid`` 填充，确保审计链路可追溯操作人。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from datetime import datetime
|
||
from typing import Any, Literal
|
||
|
||
from fastapi import APIRouter, Body, Depends, Path, Query
|
||
from pydantic import BaseModel, ConfigDict, Field
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
from yuxi.external_systems.infrastructure.container import create_use_cases_from_db
|
||
from yuxi.external_systems.use_cases.dto.alert import (
|
||
AcknowledgeAlertInput,
|
||
AlertStatsInput,
|
||
BatchAcknowledgeAlertsInput,
|
||
BatchResolveAlertsInput,
|
||
FireAlertInput,
|
||
GetAlertContextInput,
|
||
GetAlertInput,
|
||
GetAlertNotificationsInput,
|
||
ListAlertsByTraceInput,
|
||
ListAlertsInput,
|
||
ResolveAlertInput,
|
||
)
|
||
from yuxi.storage.postgres.models_business import User
|
||
|
||
from server.utils.auth_middleware import get_admin_user, get_db, get_required_user
|
||
|
||
alert_router = APIRouter(prefix="/alerts", tags=["external-systems-alert"])
|
||
|
||
|
||
# ---------------- Request Schemas ----------------
|
||
|
||
|
||
class FireAlertRequest(BaseModel):
|
||
"""触发告警请求体。字段对齐 ``FireAlertInput``。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
system_id: int | None = Field(default=None, ge=1)
|
||
alert_type: str = Field(..., min_length=1, max_length=64)
|
||
title: str = Field(..., min_length=1, max_length=256)
|
||
triggered_at: datetime
|
||
env_key: str | None = Field(default=None, max_length=32)
|
||
severity: Literal["info", "warning", "critical", "fatal"] = "warning"
|
||
description: str | None = None
|
||
detail: dict[str, Any] = Field(default_factory=dict)
|
||
resource_type: str | None = Field(default=None, max_length=32)
|
||
resource_id: str | None = Field(default=None, max_length=128)
|
||
related_execution_id: str | None = Field(default=None, max_length=64)
|
||
related_trace_id: str | None = Field(default=None, max_length=64)
|
||
metric_snapshot: dict[str, Any] | None = None
|
||
dedup_key: str | None = Field(default=None, max_length=256)
|
||
|
||
|
||
class AcknowledgeAlertRequest(BaseModel):
|
||
"""确认告警请求体。``acknowledged_by`` 由当前管理员填充，仅暴露 ``note``。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
note: str | None = None
|
||
|
||
|
||
class ResolveAlertRequest(BaseModel):
|
||
"""恢复告警请求体。字段对齐 ``ResolveAlertInput``（不含 id / user）。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
resolution_note: str | None = None
|
||
|
||
|
||
class BatchAcknowledgeAlertsRequest(BaseModel):
|
||
"""批量确认告警请求体。字段对齐 ``BatchAcknowledgeAlertsInput``（不含 acknowledged_by）。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
alert_ids: list[int] = Field(..., min_length=1, max_length=100)
|
||
note: str | None = None
|
||
|
||
|
||
class BatchResolveAlertsRequest(BaseModel):
|
||
"""批量恢复告警请求体。字段对齐 ``BatchResolveAlertsInput``（不含 user）。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
alert_ids: list[int] = Field(..., min_length=1, max_length=100)
|
||
resolution_note: str | None = None
|
||
|
||
|
||
# ---------------- Endpoints ----------------
|
||
|
||
|
||
@alert_router.get("", response_model=dict)
|
||
async def list_alerts(
|
||
limit: int = Query(100, ge=1, le=500),
|
||
offset: int = Query(0, ge=0),
|
||
system_id: int | None = Query(None, ge=1),
|
||
env_key: str | None = Query(None, max_length=32),
|
||
alert_type: str | None = Query(None, max_length=64),
|
||
severity: Literal["info", "warning", "critical", "fatal"] | None = Query(
|
||
None, description="严重度：info/warning/critical/fatal"
|
||
),
|
||
status: Literal["firing", "acknowledged", "resolved", "suppressed"] | None = Query(
|
||
None, description="告警状态：firing/acknowledged/resolved/suppressed"
|
||
),
|
||
start_time: datetime | None = Query(None, description="ISO8601 开始时间"),
|
||
end_time: datetime | None = Query(None, description="ISO8601 结束时间"),
|
||
# 新增查询参数
|
||
resource_type: str | None = Query(None, max_length=32),
|
||
resource_id: str | None = Query(None, max_length=128),
|
||
related_trace_id: str | None = Query(None, max_length=64),
|
||
dedup_key: str | None = Query(None, max_length=256),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""分页列出告警事件（支持 resource_type / resource_id / related_trace_id / dedup_key 过滤）。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = ListAlertsInput(
|
||
limit=limit,
|
||
offset=offset,
|
||
system_id=system_id,
|
||
env_key=env_key,
|
||
alert_type=alert_type,
|
||
severity=severity,
|
||
status=status,
|
||
start_at=start_time,
|
||
end_at=end_time,
|
||
resource_type=resource_type,
|
||
resource_id=resource_id,
|
||
related_trace_id=related_trace_id,
|
||
dedup_key=dedup_key,
|
||
)
|
||
output = await use_cases.alert_service.list_alerts(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@alert_router.get("/stats", response_model=dict)
|
||
async def get_alert_stats(
|
||
system_id: int | None = Query(None, ge=1),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""查询告警统计聚合。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = AlertStatsInput(system_id=system_id)
|
||
output = await use_cases.alert_service.get_alert_stats(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@alert_router.get("/by-trace/{trace_id}", response_model=dict)
|
||
async def list_alerts_by_trace(
|
||
trace_id: str,
|
||
limit: int = Query(100, ge=1, le=500),
|
||
offset: int = Query(0, ge=0),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""按链路 ID 查询告警（通过 related_trace_id 关联，支持分页）。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = ListAlertsByTraceInput(
|
||
trace_id=trace_id,
|
||
limit=limit,
|
||
offset=offset,
|
||
)
|
||
output = await use_cases.alert_service.list_alerts_by_trace(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@alert_router.post("/batch-acknowledge", response_model=dict)
|
||
async def batch_acknowledge_alerts(
|
||
payload: BatchAcknowledgeAlertsRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""批量确认告警。``acknowledged_by`` 由当前管理员填充。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = BatchAcknowledgeAlertsInput(
|
||
alert_ids=payload.alert_ids,
|
||
note=payload.note,
|
||
acknowledged_by=current_user.uid,
|
||
)
|
||
output = await use_cases.alert_service.batch_acknowledge_alerts(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@alert_router.post("/batch-resolve", response_model=dict)
|
||
async def batch_resolve_alerts(
|
||
payload: BatchResolveAlertsRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""批量恢复告警。``user`` 由当前管理员填充，确保审计可追溯。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = BatchResolveAlertsInput(
|
||
alert_ids=payload.alert_ids,
|
||
user=current_user.uid,
|
||
resolution_note=payload.resolution_note,
|
||
)
|
||
output = await use_cases.alert_service.batch_resolve_alerts(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@alert_router.get("/{alert_id}", response_model=dict)
|
||
async def get_alert(
|
||
alert_id: int = Path(ge=1),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""获取告警详情。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = GetAlertInput(id=alert_id)
|
||
output = await use_cases.alert_service.get_alert(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@alert_router.post("", response_model=dict)
|
||
async def fire_alert(
|
||
payload: FireAlertRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""触发告警事件。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = FireAlertInput(
|
||
**payload.model_dump(),
|
||
triggered_by=current_user.uid,
|
||
)
|
||
output = await use_cases.alert_service.fire_alert(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@alert_router.post("/{alert_id}/acknowledge", response_model=dict)
|
||
async def acknowledge_alert(
|
||
alert_id: int = Path(ge=1),
|
||
payload: AcknowledgeAlertRequest = Body(...),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""确认告警。``acknowledged_by`` 由当前管理员 uid 填充，``note`` 可选。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = AcknowledgeAlertInput(
|
||
id=alert_id,
|
||
acknowledged_by=current_user.uid,
|
||
note=payload.note,
|
||
)
|
||
output = await use_cases.alert_service.acknowledge_alert(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@alert_router.post("/{alert_id}/resolve", response_model=dict)
|
||
async def resolve_alert(
|
||
alert_id: int = Path(ge=1),
|
||
payload: ResolveAlertRequest = Body(...),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""恢复告警。``user`` 由当前管理员 uid 填充，确保审计可追溯。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = ResolveAlertInput(
|
||
id=alert_id,
|
||
user=current_user.uid,
|
||
resolution_note=payload.resolution_note,
|
||
)
|
||
output = await use_cases.alert_service.resolve_alert(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@alert_router.get("/{alert_id}/context", response_model=dict)
|
||
async def get_alert_context(
|
||
alert_id: int = Path(ge=1),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""查询告警上下文（含执行记录 + 指标快照）。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = GetAlertContextInput(alert_id=alert_id)
|
||
output = await use_cases.alert_service.get_alert_context(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@alert_router.get("/{alert_id}/notifications", response_model=dict)
|
||
async def get_alert_notifications(
|
||
alert_id: int = Path(ge=1),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""查询告警通知状态。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = GetAlertNotificationsInput(alert_id=alert_id)
|
||
output = await use_cases.alert_service.get_alert_notifications(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|