jettask 0.2.15__py3-none-any.whl → 0.2.16__py3-none-any.whl

jettask/{webui/multi_namespace_consumer.py → multi_namespace_consumer.py}

@@ -17,8 +17,8 @@ from datetime import datetime
 # 添加项目路径
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
 
-from jettask.webui.pg_consumer import PostgreSQLConsumer
-from jettask.webui.config import PostgreSQLConfig, RedisConfig
+from jettask.pg_consumer import PostgreSQLConsumer
+from jettask.webui_config import PostgreSQLConfig, RedisConfig
 from jettask.core.consumer_manager import ConsumerStrategy
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
 from sqlalchemy.orm import sessionmaker
@@ -268,6 +268,9 @@ class MultiNamespaceConsumerManager:
         if '/api/namespaces/' in base_url:
             # 从 http://localhost:8001/api/namespaces/default 提取 http://localhost:8001
             base_url = base_url.split('/api/namespaces/')[0]
+        elif '/api/v1/namespaces/' in base_url:
+            # 从 http://localhost:8001/api/v1/namespaces/default 提取 http://localhost:8001
+            base_url = base_url.split('/api/v1/namespaces/')[0]
         
         # 获取API服务的配置端点
         config_url = f"{base_url}/api/config"

jettask/{webui/pg_consumer.py → pg_consumer.py}

@@ -17,7 +17,7 @@ from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy import text
 
-from jettask.webui.config import PostgreSQLConfig, RedisConfig
+from jettask.webui_config import PostgreSQLConfig, RedisConfig
 from jettask.core.consumer_manager import ConsumerManager, ConsumerStrategy
 from jettask.core.offline_worker_recovery import OfflineWorkerRecovery
 from jettask.constants import is_internal_consumer, TASK_STATUS_PRIORITY
@@ -90,6 +90,10 @@ class PostgreSQLConsumer:
         self.backlog_monitor_lock_key = f"{prefix}:BACKLOG_MONITOR_LOCK"  # 分布式锁键
         self.backlog_monitor_lock_ttl = backlog_monitor_interval * 2  # 锁的TTL（秒），设为采集间隔的2倍
         
+        # 队列注册表（替代scan命令）
+        self.queue_registry_key = f"{prefix}:QUEUE_REGISTRY"  # 队列注册表的Redis key
+        self.stream_registry_key = f"{prefix}:STREAM_REGISTRY"  # Stream注册表的Redis key（用于积压监控）
+        
     async def start(self):
         """启动消费者"""
         logger.info(f"Starting PostgreSQL consumer (simplified) on node: {self.node_id}")
@@ -142,7 +146,7 @@ class PostgreSQLConsumer:
         
         # 创建SQLAlchemy异步引擎
         if self.pg_config.dsn.startswith('postgresql://'):
-            dsn = self.pg_config.dsn.replace('postgresql://', 'postgresql+psycopg://', 1)
+            dsn = self.pg_config.dsn.replace('postgresql://', 'postgresql+asyncpg://', 1)
         else:
             dsn = self.pg_config.dsn
             
@@ -238,24 +242,39 @@ class PostgreSQLConsumer:
         logger.debug("PostgreSQL consumer stopped")
    
     async def _initial_queue_discovery(self):
-        """初始队列发现，在启动时执行一次"""
+        """初始队列发现，在启动时执行一次 - 使用队列注册表替代scan"""
         try:
-            pattern = f"{self.prefix}:QUEUE:*"
             new_queues = set()
-            logger.info(f"Starting initial queue discovery with pattern: {pattern}")
+            logger.info(f"Starting initial queue discovery from queue registry: {self.queue_registry_key}")
             
-            async for key in self.redis_client.scan_iter(match=pattern, count=100):
-                # 从key中提取队列名，格式可能是：
-                # - prefix:QUEUE:queue_name (普通队列)
-                # - prefix:QUEUE:queue_name:priority (优先级队列)
-                key_str = key.decode('utf-8')
-                parts = key_str.split(":")
-                if len(parts) >= 3:
-                    # 去掉前缀和QUEUE部分
-                    queue_parts = parts[2:]  # 从第3部分开始是队列名
-                    queue_name = ":".join(queue_parts)  # 重新组合，保留优先级部分
-                    new_queues.add(queue_name)
-                    logger.info(f"Found queue: {queue_name} from key: {key_str}")
+            # 从队列注册表获取所有队列
+            queue_members = await self.redis_client.smembers(self.queue_registry_key.encode())
+            for queue_name_bytes in queue_members:
+                queue_name = queue_name_bytes.decode('utf-8') if isinstance(queue_name_bytes, bytes) else str(queue_name_bytes)
+                new_queues.add(queue_name)
+                logger.info(f"Found registered queue: {queue_name}")
+            
+            # 如果注册表为空，进行一次性的scan作为初始化（仅在首次运行时）
+            if not new_queues:
+                logger.warning(f"Queue registry is empty, performing one-time scan initialization...")
+                pattern = f"{self.prefix}:QUEUE:*"
+                async for key in self.redis_client.scan_iter(match=pattern, count=100):
+                    key_str = key.decode('utf-8')
+                    parts = key_str.split(":")
+                    if len(parts) >= 3:
+                        # 去掉前缀和QUEUE部分
+                        queue_parts = parts[2:]  # 从第3部分开始是队列名
+                        queue_name = ":".join(queue_parts)  # 重新组合，保留优先级部分
+                        new_queues.add(queue_name)
+                        logger.info(f"Found queue during scan: {queue_name} from key: {key_str}")
+                
+                # 将发现的队列添加到注册表中
+                if new_queues:
+                    pipeline = self.redis_client.pipeline()
+                    for queue_name in new_queues:
+                        pipeline.sadd(self.queue_registry_key.encode(), queue_name.encode())
+                    await pipeline.execute()
+                    logger.info(f"Registered {len(new_queues)} queues to registry during initialization")
             
             if new_queues:
                 logger.info(f"Initial queue discovery found {len(new_queues)} queues: {new_queues}")
@@ -292,35 +311,34 @@ class PostgreSQLConsumer:
             logger.error(f"Error in initial queue discovery: {e}")
     
     async def _discover_queues(self):
-        """定期发现新队列"""
+        """定期发现新队列 - 使用队列注册表替代scan"""
         while self._running:
             try:
-                pattern = f"{self.prefix}:QUEUE:*"
                 new_queues = set()
-                # logger.info(f'{pattern=}')
-                async for key in self.redis_client.scan_iter(match=pattern, count=100):
-                    # 从key中提取队列名，格式可能是：
-                    # - prefix:QUEUE:queue_name (普通队列)
-                    # - prefix:QUEUE:queue_name:priority (优先级队列)
-                    key_str = key.decode('utf-8')
-                    parts = key_str.split(":")
-                    if len(parts) >= 3:
-                        # 去掉前缀和QUEUE部分
-                        queue_parts = parts[2:]  # 从第3部分开始是队列名
-                        queue_name = ":".join(queue_parts)  # 重新组合，保留优先级部分
-                        new_queues.add(queue_name)
                 
-                # 为新发现的队列创建消费者组
-                for queue in new_queues - self._known_queues:
-                    # 正确构建stream_key，保留优先级部分
-                    stream_key = f"{self.prefix}:QUEUE:{queue}"
-                    try:
-                        await self.redis_client.xgroup_create(
-                            stream_key, self.consumer_group, id='0', mkstream=True
-                        )
-                        logger.info(f"Created consumer group for new queue: {queue} with stream_key: {stream_key}")
-                    except redis.ResponseError:
-                        pass
+                # 从队列注册表获取所有队列
+                queue_members = await self.redis_client.smembers(self.queue_registry_key.encode())
+                for queue_name_bytes in queue_members:
+                    queue_name = queue_name_bytes.decode('utf-8') if isinstance(queue_name_bytes, bytes) else str(queue_name_bytes)
+                    new_queues.add(queue_name)
+                
+                # 优化：添加日志，只在队列数量或内容发生变化时记录
+                if len(new_queues) != len(self._known_queues) or new_queues != self._known_queues:
+                    logger.debug(f"Queue registry contains {len(new_queues)} queues: {sorted(new_queues)}")
+                
+                # 为新发现的队列创建消费者组（注意：新队列应该通过生产者自动注册）
+                new_discovered = new_queues - self._known_queues
+                if new_discovered:
+                    for queue in new_discovered:
+                        # 正确构建stream_key，保留优先级部分
+                        stream_key = f"{self.prefix}:QUEUE:{queue}"
+                        try:
+                            await self.redis_client.xgroup_create(
+                                stream_key, self.consumer_group, id='0', mkstream=True
+                            )
+                            logger.info(f"Created consumer group for new queue: {queue} with stream_key: {stream_key}")
+                        except redis.ResponseError:
+                            pass
                 
                 # 更新ConsumerManager的队列列表（同步操作）
                 if new_queues != self._known_queues:
@@ -353,7 +371,7 @@ class PostgreSQLConsumer:
                             logger.error(f"Error updating worker queues: {e}")
                 
                 self._known_queues = new_queues
-                await asyncio.sleep(30)
+                await asyncio.sleep(10)  # 保持较短的检查间隔，确保新队列能及时发现
                 
             except Exception as e:
                 import traceback
@@ -1347,42 +1365,92 @@ class PostgreSQLConsumer:
             except Exception as e:
                 logger.debug(f"No TASK_OFFSETS found for {task_offsets_key}: {e}")
             
-            # 使用SCAN命令扫描所有队列Stream（包括普通队列和优先级队列）
+            # 使用Stream注册表替代SCAN命令获取队列信息
             stream_info_map = {}  # {queue_name: [(stream_key, priority), ...]}
-            pattern = f"{self.prefix}:QUEUE:*".encode()
-            cursor = 0
             
-            # 使用SCAN命令，增大count参数以提高效率
-            while True:
-                cursor, keys = await self.redis_client.scan(cursor, match=pattern, count=10000)
-                
-                for key in keys:
-                    key_str = key.decode()
-                    # 移除前缀 "prefix:QUEUE:"
-                    queue_part = key_str.replace(f"{self.prefix}:QUEUE:", "")
-                    
-                    # 检查是否是优先级队列（格式：queue_name:priority）
-                    parts = queue_part.split(':')
+            # 从fredis中获取stream注册表（Hash结构）
+            # 格式: {"queue_name:priority": "stream_key"}
+            # 对于普通队列，priority为0
+            stream_registry = await self.redis_client.hgetall(self.stream_registry_key.encode())
+            
+            for queue_priority_bytes, stream_key_bytes in stream_registry.items():
+                queue_priority_str = queue_priority_bytes.decode() if isinstance(queue_priority_bytes, bytes) else str(queue_priority_bytes)
+                stream_key = stream_key_bytes.decode() if isinstance(stream_key_bytes, bytes) else str(stream_key_bytes)
+                
+                # 解析queue_name和priority
+                if ':' in queue_priority_str:
+                    parts = queue_priority_str.rsplit(':', 1)
                     if len(parts) == 2 and parts[1].isdigit():
-                        # 优先级队列
                         queue_name = parts[0]
                         priority = int(parts[1])
+                    else:
+                        # 如果最后一部分不是数字，说明是普通队列名包含冒号
+                        queue_name = queue_priority_str
+                        priority = 0
+                else:
+                    # 普通队列
+                    queue_name = queue_priority_str
+                    priority = 0
+                
+                if queue_name not in stream_info_map:
+                    stream_info_map[queue_name] = []
+                stream_info_map[queue_name].append((stream_key, priority))
+            
+            # 如果Stream注册表为空，进行一次性的scan作为初始化（仅在首次运行时）
+            if not stream_info_map:
+                logger.warning(f"Stream registry is empty, performing one-time scan initialization...")
+                pattern = f"{self.prefix}:QUEUE:*".encode()
+                cursor = 0
+                
+                while True:
+                    cursor, keys = await self.redis_client.scan(cursor, match=pattern, count=10000)
+                    
+                    for key in keys:
+                        key_str = key.decode()
+                        # 移除前缀 "prefix:QUEUE:"
+                        queue_part = key_str.replace(f"{self.prefix}:QUEUE:", "")
+                        
+                        # 检查是否是优先级队列（格式：queue_name:priority）
+                        parts = queue_part.split(':')
+                        if len(parts) == 2 and parts[1].isdigit():
+                            # 优先级队列
+                            queue_name = parts[0]
+                            priority = int(parts[1])
+                            queue_priority_key = f"{queue_name}:{priority}"
+                        elif ':' not in queue_part:
+                            # 普通队列（不包含冒号）
+                            queue_name = queue_part
+                            priority = 0
+                            queue_priority_key = queue_name
+                        else:
+                            # 忽略其他格式的键（如消费组等）
+                            continue
+                        
                         if queue_name not in stream_info_map:
                             stream_info_map[queue_name] = []
                         stream_info_map[queue_name].append((key, priority))
-                    elif ':' not in queue_part:
-                        # 普通队列（不包含冒号）
-                        queue_name = queue_part
-                        if queue_name not in stream_info_map:
-                            stream_info_map[queue_name] = []
-                        stream_info_map[queue_name].append((key, 0))  # 普通队列优先级为0
-                    # 忽略其他格式的键（如消费组等）
-                
-                if cursor == 0:
-                    break
+                    
+                    if cursor == 0:
+                        break
+                
+                # 将发现的Stream信息添加到注册表中
+                if stream_info_map:
+                    pipeline = self.redis_client.pipeline()
+                    for queue_name, stream_list in stream_info_map.items():
+                        for stream_key, priority in stream_list:
+                            if priority > 0:
+                                queue_priority_key = f"{queue_name}:{priority}"
+                            else:
+                                queue_priority_key = queue_name
+                            # stream_key已经是bytes类型（从scan_iter返回）
+                            if isinstance(stream_key, str):
+                                stream_key = stream_key.encode()
+                            pipeline.hset(self.stream_registry_key.encode(), queue_priority_key.encode(), stream_key)
+                    await pipeline.execute()
+                    logger.info(f"Registered {sum(len(stream_list) for stream_list in stream_info_map.values())} streams to registry during initialization")
             
             if not stream_info_map:
-                logger.debug("No streams found for backlog monitoring")
+                logger.debug("No streams found in registry for backlog monitoring")
                 return
             
             # 调试日志（使用debug级别避免刷屏）

jettask/{webui/run.py → run.py}

@@ -11,7 +11,7 @@ import sys
 import os
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
 
-from jettask.webui.api import app, monitor
+from jettask.api import app, monitor
 import uvicorn
 
 def main():

jettask/{webui/run_webui.py → run_webui.py}

@@ -17,13 +17,13 @@ from pathlib import Path
 project_root = Path(__file__).parent.parent.parent
 sys.path.insert(0, str(project_root))
 
-from jettask.webui.config import PostgreSQLConfig
+from jettask.webui_config import PostgreSQLConfig
 
 
 def run_fastapi_server(host: str = "0.0.0.0", port: int = 8000, with_consumer: bool = False):
     """运行FastAPI服务器"""
     import uvicorn
-    from jettask.webui.api import app
+    from jettask.api import app
     
     # 如果需要启动消费者
     if with_consumer:
@@ -54,7 +54,7 @@ def run_gradio_interface(host: str = "0.0.0.0", port: int = 7860, share: bool =
     print("You can start it with: python -m jettask.webui.run_webui --mode fastapi")
     print()
     
-    from jettask.webui.gradio_app import create_interface
+    from jettask.gradio_app import create_interface
     
     app = create_interface()
     print(f"Starting Gradio interface on http://{host}:{port}")
@@ -94,7 +94,7 @@ def run_combined_mode(host: str = "0.0.0.0", api_port: int = 8000, ui_port: int
 
 def run_integrated_gradio(host: str = "0.0.0.0", port: int = 7860, share: bool = False):
     """运行集成的Gradio界面（直接访问数据源）"""
-    from jettask.webui.integrated_gradio_app import create_integrated_interface
+    from jettask.integrated_gradio_app import create_integrated_interface
     
     print("Starting Integrated Gradio interface (direct data access)...")
     print(f"Access the interface at http://{host}:{port}")

jettask/scheduler/multi_namespace_scheduler.py

@@ -9,7 +9,7 @@ import traceback
 from typing import Dict, Set
 
 from jettask import Jettask
-from jettask.webui.task_center import TaskCenter
+from jettask.task_center import TaskCenter
 from jettask.scheduler.scheduler import TaskScheduler
 from jettask.scheduler.manager import ScheduledTaskManager
 
@@ -219,7 +219,7 @@ def run_scheduler_for_namespace(namespace: str,
         scheduler_instance = None
         try:
             # 构建命名空间特定的URL
-            task_center_url = f"{task_center_base_url}/api/namespaces/{namespace}"
+            task_center_url = f"{task_center_base_url}/api/v1/namespaces/{namespace}"
             logger.info(f"连接到任务中心: {task_center_url}")
             
             # 连接任务中心

jettask/scheduler/unified_manager.py

@@ -11,7 +11,7 @@ import aiohttp
 import traceback
 
 from jettask import Jettask
-from jettask.webui.task_center import TaskCenter
+from jettask.task_center import TaskCenter
 from .scheduler import TaskScheduler
 from .manager import ScheduledTaskManager
 
@@ -133,9 +133,9 @@ class UnifiedSchedulerManager:
         try:
             # 构建API URL
             if self.task_center_url.endswith('/api'):
-                url = f"{self.task_center_url}/namespaces"
+                url = f"{self.task_center_url}/v1/namespaces"
             else:
-                url = f"{self.task_center_url}/api/namespaces"
+                url = f"{self.task_center_url}/api/v1/namespaces"
             
             async with aiohttp.ClientSession() as session:
                 async with session.get(url) as response:
@@ -223,9 +223,9 @@ class UnifiedSchedulerManager:
         
         # 构建命名空间URL
         if self.task_center_url.endswith('/api'):
-            namespace_url = f"{self.task_center_url}/namespaces/{namespace}"
+            namespace_url = f"{self.task_center_url}/v1/namespaces/{namespace}"
         else:
-            namespace_url = f"{self.task_center_url}/api/namespaces/{namespace}"
+            namespace_url = f"{self.task_center_url}/api/v1/namespaces/{namespace}"
         
         # 创建新进程
         process = multiprocessing.Process(

jettask/scheduler/unified_scheduler_manager.py

@@ -8,7 +8,7 @@ import multiprocessing
 from typing import Dict, Optional, Set
 from jettask.core.unified_manager_base import UnifiedManagerBase
 from jettask import Jettask
-from jettask.webui.task_center import TaskCenter
+from jettask.task_center import TaskCenter
 from .scheduler import TaskScheduler
 from .manager import ScheduledTaskManager
 

jettask/schemas/__init__.py

@@ -0,0 +1,166 @@
+"""
+数据模型定义
+所有的Pydantic模型集中管理
+"""
+
+# 任务相关模型
+from .task import (
+    TasksRequest,
+    TaskDetailResponse,
+    TaskInfo,
+    TaskActionRequest,
+    TaskListResponse
+)
+
+# 队列相关模型
+from .queue import (
+    TimeRangeQuery,
+    QueueStatsResponse,
+    QueueTimelineResponse,
+    TrimQueueRequest,
+    QueueInfo,
+    QueueStats,
+    QueueActionRequest
+)
+
+# 定时任务相关模型
+from .scheduled_task import (
+    ScheduledTaskRequest,
+    ScheduledTaskResponse,
+    ScheduledTaskInfo,
+    ScheduleConfig,
+    ScheduledTaskCreate,
+    ScheduledTaskUpdate,
+    ScheduledTaskCreateRequest
+)
+
+# 告警相关模型
+from .alert import (
+    AlertRuleRequest,
+    AlertRuleCreate,
+    AlertRuleUpdate,
+    AlertRule,
+    AlertInstance,
+    AlertSummary
+)
+
+# 命名空间相关模型
+from .namespace import (
+    ConfigMode,
+    NamespaceCreate,
+    NamespaceUpdate,
+    NamespaceResponse,
+    NamespaceInfo,
+    NamespaceCreateRequest,
+    NamespaceUpdateRequest
+)
+
+# 积压监控相关模型
+from .backlog import (
+    BacklogTrendRequest,
+    BacklogSnapshot,
+    BacklogStatistics,
+    BacklogTrendResponse,
+    BacklogAlert
+)
+
+# 通用模型
+from .common import (
+    ErrorResponse,
+    FilterCondition,
+    BaseListRequest,
+    TimeRangeRequest,
+    BatchOperationRequest,
+    BatchOperationResponse,
+    PaginationResponse,
+    ListResponse,
+    HealthCheck,
+    SystemConfigUpdateRequest,
+    ApiResponse
+)
+
+# 监控和分析模型
+from .monitoring import (
+    MetricPoint,
+    TimeSeries,
+    MonitoringMetrics,
+    AnalyticsData,
+    SystemHealth,
+    DashboardOverviewRequest,
+    DashboardOverview,
+    WorkerMetrics
+)
+
+__all__ = [
+    # Task
+    'TasksRequest',
+    'TaskDetailResponse',
+    'TaskInfo',
+    'TaskActionRequest',
+    'TaskListResponse',
+    
+    # Queue
+    'TimeRangeQuery',
+    'QueueStatsResponse',
+    'QueueTimelineResponse',
+    'TrimQueueRequest',
+    'QueueInfo',
+    'QueueStats',
+    'QueueActionRequest',
+    
+    # Scheduled Task
+    'ScheduledTaskRequest',
+    'ScheduledTaskResponse',
+    'ScheduledTaskInfo',
+    'ScheduleConfig',
+    'ScheduledTaskCreate',
+    'ScheduledTaskUpdate',
+    'ScheduledTaskCreateRequest',
+    
+    # Alert
+    'AlertRuleRequest',
+    'AlertRuleCreate',
+    'AlertRuleUpdate',
+    'AlertRule',
+    'AlertInstance',
+    'AlertSummary',
+    
+    # Namespace
+    'ConfigMode',
+    'NamespaceCreate',
+    'NamespaceUpdate',
+    'NamespaceResponse',
+    'NamespaceInfo',
+    'NamespaceCreateRequest',
+    'NamespaceUpdateRequest',
+    
+    # Backlog
+    'BacklogTrendRequest',
+    'BacklogSnapshot',
+    'BacklogStatistics',
+    'BacklogTrendResponse',
+    'BacklogAlert',
+    
+    # Common
+    'ErrorResponse',
+    'FilterCondition',
+    'BaseListRequest',
+    'TimeRangeRequest',
+    'BatchOperationRequest',
+    'BatchOperationResponse',
+    'PaginationResponse',
+    'ListResponse',
+    'HealthCheck',
+    'SystemConfigUpdateRequest',
+    'ApiResponse',
+    
+    # Monitoring
+    'MetricPoint',
+    'TimeSeries',
+    'MonitoringMetrics',
+    'AnalyticsData',
+    'SystemHealth',
+    'DashboardOverviewRequest',
+    'DashboardOverview',
+    'WorkerMetrics'
+]

jettask/schemas/alert.py

@@ -0,0 +1,99 @@
+"""
+告警相关的数据模型
+"""
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class AlertRuleRequest(BaseModel):
+    """告警规则请求模型"""
+    rule_name: str = Field(..., description="规则名称")
+    metric_type: str = Field(..., description="指标类型")
+    threshold: float = Field(..., description="阈值")
+    operator: str = Field(..., description="比较操作符", pattern="^(gt|gte|lt|lte|eq|ne)$")
+    duration: int = Field(..., ge=1, description="持续时间（秒）")
+    severity: str = Field(..., description="严重级别", pattern="^(low|medium|high|critical)$")
+    enabled: bool = Field(default=True, description="是否启用")
+    description: Optional[str] = Field(None, description="规则描述")
+
+
+class AlertRuleCreate(BaseModel):
+    """创建告警规则请求模型"""
+    name: str = Field(..., description="规则名称")
+    description: Optional[str] = Field(None, description="规则描述")
+    metric_type: str = Field(..., description="监控指标类型")
+    threshold: float = Field(..., description="告警阈值")
+    comparison_operator: str = Field(..., description="比较操作符")
+    evaluation_window: int = Field(..., description="评估窗口（秒）")
+    severity: str = Field(..., description="告警级别")
+    notification_channels: List[str] = Field(default=[], description="通知渠道")
+    enabled: bool = Field(default=True, description="是否启用")
+
+
+class AlertRuleUpdate(BaseModel):
+    """更新告警规则请求模型"""
+    name: Optional[str] = Field(None, description="规则名称")
+    description: Optional[str] = Field(None, description="规则描述")
+    metric_type: Optional[str] = Field(None, description="监控指标类型")
+    threshold: Optional[float] = Field(None, description="告警阈值")
+    comparison_operator: Optional[str] = Field(None, description="比较操作符")
+    evaluation_window: Optional[int] = Field(None, description="评估窗口（秒）")
+    severity: Optional[str] = Field(None, description="告警级别")
+    notification_channels: Optional[List[str]] = Field(None, description="通知渠道")
+    enabled: Optional[bool] = Field(None, description="是否启用")
+
+
+class AlertRule(BaseModel):
+    """告警规则模型"""
+    id: str = Field(..., description="规则ID")
+    name: str = Field(..., description="规则名称")
+    description: Optional[str] = Field(None, description="规则描述")
+    metric_type: str = Field(..., description="监控指标类型")
+    threshold: float = Field(..., description="告警阈值")
+    comparison_operator: str = Field(..., description="比较操作符")
+    evaluation_window: int = Field(..., description="评估窗口（秒）")
+    severity: str = Field(..., description="告警级别")
+    notification_channels: List[str] = Field(default=[], description="通知渠道")
+    enabled: bool = Field(default=True, description="是否启用")
+    created_at: datetime = Field(..., description="创建时间")
+    updated_at: Optional[datetime] = Field(None, description="更新时间")
+    
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat() if v else None
+        }
+
+
+class AlertInstance(BaseModel):
+    """告警实例模型"""
+    id: str = Field(..., description="告警实例ID")
+    rule_id: str = Field(..., description="规则ID")
+    rule_name: str = Field(..., description="规则名称")
+    status: str = Field(..., description="告警状态", pattern="^(active|resolved|suppressed)$")
+    severity: str = Field(..., description="告警级别")
+    message: str = Field(..., description="告警消息")
+    metric_value: float = Field(..., description="当前指标值")
+    threshold: float = Field(..., description="阈值")
+    started_at: datetime = Field(..., description="开始时间")
+    resolved_at: Optional[datetime] = Field(None, description="解决时间")
+    acknowledged_at: Optional[datetime] = Field(None, description="确认时间")
+    acknowledged_by: Optional[str] = Field(None, description="确认人")
+    namespace: str = Field(..., description="命名空间")
+    labels: Dict[str, str] = Field(default={}, description="标签")
+    
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat() if v else None
+        }
+
+
+class AlertSummary(BaseModel):
+    """告警摘要模型"""
+    total_alerts: int = Field(default=0, description="总告警数")
+    active_alerts: int = Field(default=0, description="活跃告警数")
+    resolved_alerts: int = Field(default=0, description="已解决告警数")
+    critical_alerts: int = Field(default=0, description="严重告警数")
+    high_alerts: int = Field(default=0, description="高级告警数")
+    medium_alerts: int = Field(default=0, description="中级告警数")
+    low_alerts: int = Field(default=0, description="低级告警数")