jettask 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

jettask/core/cli.py

@@ -474,6 +474,248 @@ def scheduler(task_center, interval, batch_size, check_interval, debug):
     except KeyboardInterrupt:
         click.echo("\nShutdown complete")
 
+@cli.command()
+@click.option('--port', default=8080, help='前端服务器端口')
+@click.option('--host', default='0.0.0.0', help='前端服务器监听地址')
+@click.option('--auto-install', is_flag=True, default=True, help='自动安装缺失的依赖')
+@click.option('--force-install', is_flag=True, help='强制重新安装依赖')
+@click.option('--build-only', is_flag=True, help='仅构建生产版本，不启动服务器')
+def frontend(port, host, auto_install, force_install, build_only):
+    """启动 WebUI 前端界面
+    
+    启动生产版本服务器：
+    1. 检查 Node.js 和 npm 是否安装
+    2. 复制前端代码到用户目录并安装依赖
+    3. 构建并启动生产版本服务器
+    
+    示例：
+      # 启动生产版本服务器（默认）
+      jettask frontend
+      
+      # 指定端口
+      jettask frontend --port 3000
+      
+      # 仅构建生产版本
+      jettask frontend --build-only
+      
+      # 强制重新安装依赖
+      jettask frontend --force-install
+    """
+    import subprocess
+    import shutil
+    from pathlib import Path
+    
+    # 获取源前端目录路径（包中的）
+    source_frontend_dir = Path(__file__).parent.parent / "webui" / "frontend"
+    if not source_frontend_dir.exists():
+        click.echo(f"错误：前端源目录不存在: {source_frontend_dir}", err=True)
+        sys.exit(1)
+    
+    # 获取用户工作目录（在用户主目录下）
+    user_home = Path.home()
+    user_jettask_dir = user_home / ".jettask"
+    user_frontend_dir = user_jettask_dir / "frontend"
+    
+    # 确保用户目录存在
+    user_jettask_dir.mkdir(parents=True, exist_ok=True)
+    
+    # 检查是否需要复制/更新前端代码
+    should_copy = False
+    if not user_frontend_dir.exists():
+        should_copy = True
+        click.echo(f"首次使用，正在初始化前端环境...")
+    else:
+        # 检查版本或时间戳来决定是否需要更新
+        source_package_json = source_frontend_dir / "package.json"
+        user_package_json = user_frontend_dir / "package.json"
+        if not user_package_json.exists():
+            should_copy = True
+        else:
+            # 比较修改时间
+            if source_package_json.stat().st_mtime > user_package_json.stat().st_mtime:
+                should_copy = True
+                click.echo("检测到前端代码更新，正在同步...")
+    
+    if should_copy:
+        # 复制前端代码到用户目录
+        if user_frontend_dir.exists():
+            # 保留 node_modules 和 dist 目录
+            node_modules_backup = None
+            dist_backup = None
+            
+            node_modules_dir = user_frontend_dir / "node_modules"
+            dist_dir = user_frontend_dir / "dist"
+            
+            if node_modules_dir.exists() and not force_install:
+                # 备份 node_modules
+                node_modules_backup = user_jettask_dir / "node_modules_backup"
+                if node_modules_backup.exists():
+                    shutil.rmtree(node_modules_backup)
+                shutil.move(str(node_modules_dir), str(node_modules_backup))
+            
+            if dist_dir.exists():
+                # 备份 dist
+                dist_backup = user_jettask_dir / "dist_backup"
+                if dist_backup.exists():
+                    shutil.rmtree(dist_backup)
+                shutil.move(str(dist_dir), str(dist_backup))
+            
+            # 删除旧的前端目录
+            shutil.rmtree(user_frontend_dir)
+        
+        # 复制新的前端代码
+        shutil.copytree(source_frontend_dir, user_frontend_dir, ignore=shutil.ignore_patterns('node_modules', 'dist', '.git'))
+        
+        # 恢复备份
+        if 'node_modules_backup' in locals() and node_modules_backup and node_modules_backup.exists():
+            shutil.move(str(node_modules_backup), str(user_frontend_dir / "node_modules"))
+        
+        if 'dist_backup' in locals() and dist_backup and dist_backup.exists():
+            shutil.move(str(dist_backup), str(user_frontend_dir / "dist"))
+        
+        click.echo(f"✓ 前端代码已同步到: {user_frontend_dir}")
+    
+    # 工作目录切换到用户前端目录
+    frontend_dir = user_frontend_dir
+    
+    # 检查 Node.js 是否安装
+    node_cmd = shutil.which('node')
+    if not node_cmd:
+        click.echo("错误：未检测到 Node.js 环境", err=True)
+        click.echo("\n请先安装 Node.js:")
+        click.echo("  - Ubuntu/Debian: sudo apt-get install nodejs npm")
+        click.echo("  - macOS: brew install node")
+        click.echo("  - Windows: 从 https://nodejs.org 下载安装")
+        click.echo("  - 或使用 nvm: curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash")
+        sys.exit(1)
+    
+    # 检查 npm 是否安装
+    npm_cmd = shutil.which('npm')
+    if not npm_cmd:
+        click.echo("错误：未检测到 npm", err=True)
+        click.echo("\n请安装 npm:")
+        click.echo("  - Ubuntu/Debian: sudo apt-get install npm")
+        click.echo("  - 或重新安装 Node.js (包含 npm)")
+        sys.exit(1)
+    
+    # 显示版本信息
+    try:
+        node_version = subprocess.check_output([node_cmd, '--version'], text=True).strip()
+        npm_version = subprocess.check_output([npm_cmd, '--version'], text=True).strip()
+        click.echo(f"检测到 Node.js {node_version}, npm {npm_version}")
+    except subprocess.CalledProcessError:
+        pass
+    
+    # 切换到前端目录
+    os.chdir(frontend_dir)
+    click.echo(f"工作目录: {frontend_dir}")
+    
+    # 检查 package.json 是否存在
+    package_json = frontend_dir / "package.json"
+    if not package_json.exists():
+        click.echo("错误：package.json 文件不存在", err=True)
+        sys.exit(1)
+    
+    # 检查 node_modules 是否存在
+    node_modules = frontend_dir / "node_modules"
+    need_install = not node_modules.exists() or force_install
+    
+    if need_install and auto_install:
+        click.echo("\n正在安装依赖...")
+        try:
+            # 清理旧的 node_modules（如果强制安装）
+            if force_install and node_modules.exists():
+                click.echo("清理旧的 node_modules...")
+                shutil.rmtree(node_modules)
+            
+            # 清理 package-lock.json（如果有问题）
+            lock_file = frontend_dir / "package-lock.json"
+            if force_install and lock_file.exists():
+                lock_file.unlink()
+            
+            # 运行 npm install
+            subprocess.run([npm_cmd, 'install'], check=True)
+            click.echo("✓ 依赖安装完成")
+        except subprocess.CalledProcessError as e:
+            click.echo(f"错误：依赖安装失败 - {e}", err=True)
+            click.echo("\n可以尝试:")
+            click.echo("  1. 手动删除 node_modules 目录后重试")
+            click.echo("  2. 使用 --force-install 参数强制重新安装")
+            click.echo("  3. 检查网络连接和 npm 源设置")
+            sys.exit(1)
+    elif need_install and not auto_install:
+        click.echo("警告：未检测到 node_modules，请运行 'npm install' 安装依赖")
+        if not click.confirm("是否现在安装依赖？"):
+            sys.exit(1)
+    
+    # 构建或启动
+    try:
+        # 构建生产版本
+        dist_dir = frontend_dir / "dist"
+        
+        # 检查是否需要构建
+        need_build = not dist_dir.exists() or build_only
+        
+        # 如果 dist 不存在或明确要求构建，则进行构建
+        if need_build:
+            click.echo("\n正在构建生产版本...")
+            subprocess.run([npm_cmd, 'run', 'build'], check=True)
+            
+            if dist_dir.exists():
+                # 统计文件
+                files = list(dist_dir.rglob('*'))
+                file_count = len([f for f in files if f.is_file()])
+                total_size = sum(f.stat().st_size for f in files if f.is_file())
+                click.echo(f"\n✓ 构建完成！")
+                click.echo(f"  - 输出目录: {dist_dir}")
+                click.echo(f"  - 文件数量: {file_count}")
+                click.echo(f"  - 总大小: {total_size / 1024 / 1024:.2f} MB")
+            else:
+                click.echo("错误：构建失败，未生成输出目录", err=True)
+                sys.exit(1)
+        
+        # 如果不是仅构建模式，启动生产服务器
+        if not build_only:
+            if not dist_dir.exists():
+                click.echo("错误：未找到构建输出，请先运行构建", err=True)
+                sys.exit(1)
+            
+            click.echo(f"\n正在启动生产版本服务器...")
+            click.echo(f"  - 地址: http://{host}:{port}")
+            click.echo(f"  - 本地访问: http://localhost:{port}")
+            click.echo(f"  - 静态文件目录: {dist_dir}")
+            click.echo("\n按 Ctrl+C 停止服务器\n")
+            
+            # 使用 Python 内置的 HTTP 服务器提供静态文件
+            import http.server
+            import socketserver
+            
+            class Handler(http.server.SimpleHTTPRequestHandler):
+                def __init__(self, *args, **kwargs):
+                    super().__init__(*args, directory=str(dist_dir), **kwargs)
+                
+                def do_GET(self):
+                    # 对于 SPA 应用，所有路由都返回 index.html
+                    if self.path != '/' and not Path(dist_dir / self.path[1:]).exists():
+                        self.path = '/index.html'
+                    return super().do_GET()
+                
+                def log_message(self, format, *args):
+                    # 自定义日志格式
+                    click.echo(f"[{self.log_date_time_string()}] {format % args}")
+            
+            # 创建服务器
+            with socketserver.TCPServer((host, port), Handler) as httpd:
+                try:
+                    httpd.serve_forever()
+                except KeyboardInterrupt:
+                    pass
+    except subprocess.CalledProcessError as e:
+        click.echo(f"错误：命令执行失败 - {e}", err=True)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        click.echo("\n停止前端服务器")
+
 def main():
     """主入口函数"""
     try:

jettask/pg_consumer/sql/add_execution_time_field.sql

@@ -0,0 +1,29 @@
+-- 添加execution_time_ms字段到task_runs表
+-- execution_time_ms: 实际执行时间（毫秒），从任务开始执行到执行完成的时间
+-- duration_ms: 总耗时（毫秒），从任务创建到执行完成的时间
+
+-- 检查字段是否存在，如果不存在则添加
+DO $$ 
+BEGIN
+    IF NOT EXISTS (
+        SELECT 1 
+        FROM information_schema.columns 
+        WHERE table_name = 'task_runs' 
+        AND column_name = 'execution_time_ms'
+    ) THEN
+        ALTER TABLE task_runs 
+        ADD COLUMN execution_time_ms BIGINT;
+        
+        COMMENT ON COLUMN task_runs.execution_time_ms IS '实际执行时间（毫秒），从任务开始执行到执行完成的时间';
+        
+        -- 为已有数据计算execution_time_ms（如果有start_time和end_time）
+        UPDATE task_runs 
+        SET execution_time_ms = EXTRACT(EPOCH FROM (end_time - start_time)) * 1000
+        WHERE start_time IS NOT NULL 
+        AND end_time IS NOT NULL
+        AND execution_time_ms IS NULL;
+    END IF;
+END $$;
+
+-- 确保duration_ms字段的注释正确
+COMMENT ON COLUMN task_runs.duration_ms IS '总耗时（毫秒），从任务创建到执行完成的时间';

jettask/pg_consumer/sql/create_new_tables.sql

@@ -0,0 +1,137 @@
+-- 新的任务表结构设计
+-- 用于支持多消费者组的任务管理
+
+-- 1. 任务基础信息表 (tasks)
+-- 存储任务的元数据，一个任务只有一条记录
+CREATE TABLE IF NOT EXISTS tasks (
+    id BIGSERIAL PRIMARY KEY,                     -- 内部主键
+    stream_id TEXT UNIQUE NOT NULL,               -- Redis Stream的message id (例如: 1757039473571-0)
+    queue TEXT NOT NULL,                          -- 队列名称
+    namespace TEXT,                               -- 命名空间（多租户支持）
+    scheduled_task_id TEXT,                        -- 调度任务ID
+    payload JSONB NOT NULL,                       -- 任务参数（完整的event_data）
+    priority INT DEFAULT 0,                       -- 任务优先级
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,  -- 任务创建时间
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,  -- 更新时间
+    source TEXT,                                  -- 任务来源（例如：api/scheduler/manual）
+    metadata JSONB DEFAULT '{}'::jsonb            -- 额外的元数据
+);
+
+-- 为stream_id创建唯一索引
+CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_stream_id ON tasks(stream_id);
+
+-- 为queue创建索引，方便查询
+CREATE INDEX IF NOT EXISTS idx_tasks_queue ON tasks(queue);
+CREATE INDEX IF NOT EXISTS idx_tasks_namespace ON tasks(namespace);
+CREATE INDEX IF NOT EXISTS idx_tasks_created_at ON tasks(created_at);
+CREATE INDEX IF NOT EXISTS idx_tasks_scheduled_task_id ON tasks(scheduled_task_id);
+
+-- 为queue和namespace创建复合索引，优化查询
+CREATE INDEX IF NOT EXISTS idx_tasks_queue_namespace ON tasks(queue, namespace);
+
+-- 2. 任务运行记录表 (task_runs)
+-- 记录每个消费者组对任务的执行情况
+CREATE TABLE IF NOT EXISTS task_runs (
+    id BIGSERIAL PRIMARY KEY,                     -- 内部主键
+    task_id BIGINT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,  -- 关联任务ID
+    stream_id TEXT NOT NULL,                      -- 冗余存储stream_id方便查询
+    task_name TEXT NOT NULL,                      -- 任务名称
+    consumer_group TEXT NOT NULL,                 -- 消费者组名称
+    consumer_name TEXT,                           -- 具体的消费者实例名
+    worker_id TEXT,                               -- Worker ID
+    status TEXT NOT NULL DEFAULT 'pending',       -- 执行状态（pending/running/success/failed/retrying/timeout/skipped）
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,  -- 创建时间
+    start_time TIMESTAMPTZ,                       -- 开始执行时间
+    end_time TIMESTAMPTZ,                         -- 结束时间
+    duration DOUBLE PRECISION,  -- 执行耗时（秒），由应用层计算
+    retry_count INT DEFAULT 0,                    -- 重试次数
+    max_retries INT DEFAULT 3,                    -- 最大重试次数
+    error_message TEXT,                           -- 错误信息
+    error_details JSONB,                          -- 详细错误信息（包含堆栈等）
+    result JSONB,                                 -- 执行结果
+    logs TEXT[],                                  -- 执行日志
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP  -- 最后更新时间
+);
+
+-- 为task_id创建索引
+CREATE INDEX IF NOT EXISTS idx_task_runs_task_id ON task_runs(task_id);
+
+-- 为stream_id创建索引
+CREATE INDEX IF NOT EXISTS idx_task_runs_stream_id ON task_runs(stream_id);
+
+-- 为consumer_group创建索引
+CREATE INDEX IF NOT EXISTS idx_task_runs_consumer_group ON task_runs(consumer_group);
+
+-- 为status创建索引
+CREATE INDEX IF NOT EXISTS idx_task_runs_status ON task_runs(status);
+
+-- 创建复合索引优化查询
+CREATE INDEX IF NOT EXISTS idx_task_runs_task_group ON task_runs(task_id, consumer_group);
+CREATE INDEX IF NOT EXISTS idx_task_runs_group_status ON task_runs(consumer_group, status);
+CREATE INDEX IF NOT EXISTS idx_task_runs_stream_group ON task_runs(stream_id, consumer_group);
+
+-- 为了保证同一个任务在同一个消费者组中只有一条运行记录，创建唯一约束
+CREATE UNIQUE INDEX IF NOT EXISTS idx_task_runs_unique_task_group ON task_runs(task_id, consumer_group);
+
+-- 更新时间触发器
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- 为task_runs表创建触发器
+DROP TRIGGER IF EXISTS update_task_runs_updated_at ON task_runs;
+CREATE TRIGGER update_task_runs_updated_at 
+    BEFORE UPDATE ON task_runs 
+    FOR EACH ROW 
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- 3. 创建视图方便查询
+-- 任务执行概览视图
+CREATE OR REPLACE VIEW task_execution_overview AS
+SELECT 
+    t.id,
+    t.stream_id,
+    t.queue,
+    t.namespace,
+    t.scheduled_task_id,
+    t.created_at,
+    COUNT(DISTINCT tr.consumer_group) as consumer_group_count,
+    COUNT(tr.id) as total_runs,
+    COUNT(CASE WHEN tr.status = 'success' THEN 1 END) as success_count,
+    COUNT(CASE WHEN tr.status = 'failed' THEN 1 END) as failed_count,
+    COUNT(CASE WHEN tr.status = 'running' THEN 1 END) as running_count,
+    AVG(tr.duration * 1000) as avg_duration_ms,  -- 转换为毫秒
+    MAX(tr.end_time) as last_execution_time
+FROM tasks t
+LEFT JOIN task_runs tr ON t.id = tr.task_id
+GROUP BY t.id;
+
+-- 消费者组执行统计视图
+CREATE OR REPLACE VIEW consumer_group_stats AS
+SELECT 
+    tr.consumer_group,
+    tr.task_name,
+    t.queue,
+    t.namespace,
+    COUNT(DISTINCT tr.task_id) as total_tasks,
+    COUNT(CASE WHEN tr.status = 'success' THEN 1 END) as success_count,
+    COUNT(CASE WHEN tr.status = 'failed' THEN 1 END) as failed_count,
+    COUNT(CASE WHEN tr.status = 'running' THEN 1 END) as running_count,
+    AVG(tr.duration * 1000) as avg_duration_ms,  -- 转换为毫秒
+    SUM(tr.retry_count) as total_retries,
+    MAX(tr.end_time) as last_activity
+FROM task_runs tr
+JOIN tasks t ON tr.task_id = t.id
+GROUP BY tr.consumer_group, tr.task_name, t.queue, t.namespace;
+
+-- 添加注释
+COMMENT ON TABLE tasks IS '任务基础信息表，存储任务的元数据';
+COMMENT ON TABLE task_runs IS '任务运行记录表，记录每个消费者组对任务的执行情况';
+COMMENT ON COLUMN tasks.stream_id IS 'Redis Stream的消息ID，确保幂等性';
+COMMENT ON COLUMN tasks.payload IS '任务参数，存储完整的event_data';
+COMMENT ON COLUMN task_runs.consumer_group IS '消费者组名称，格式如：jettask:QUEUE:queue_name:task_name';
+COMMENT ON COLUMN task_runs.duration IS '执行耗时（秒），自动计算';

jettask/pg_consumer/sql/create_tables_v3.sql

@@ -0,0 +1,175 @@
+-- 优化后的任务表结构设计 V3
+-- 根据实际需求调整字段
+
+-- 1. 任务基础信息表 (tasks)
+-- 存储任务的元数据，一个任务只有一条记录
+CREATE TABLE IF NOT EXISTS tasks (
+    id BIGSERIAL PRIMARY KEY,                     -- 内部主键
+    stream_id TEXT UNIQUE NOT NULL,               -- Redis Stream的message id (例如: 1757039473571-0)
+    queue TEXT NOT NULL,                          -- 队列名称
+    namespace TEXT DEFAULT 'default',             -- 命名空间
+    scheduled_task_id TEXT,                       -- 调度任务ID（如果是调度任务产生的）
+    payload JSONB NOT NULL,                       -- 任务参数（完整的event_data）
+    priority INT DEFAULT 0,                       -- 任务优先级
+    source TEXT,                                  -- 任务来源（例如：api/scheduler/manual）
+    metadata JSONB DEFAULT '{}'::jsonb,           -- 额外的元数据
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP  -- 任务创建时间
+);
+
+-- 为stream_id创建唯一索引
+CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_stream_id ON tasks(stream_id);
+
+-- 为queue创建索引，方便查询
+CREATE INDEX IF NOT EXISTS idx_tasks_queue ON tasks(queue);
+
+-- 为namespace创建索引
+CREATE INDEX IF NOT EXISTS idx_tasks_namespace ON tasks(namespace);
+
+-- 为scheduled_task_id创建索引
+CREATE INDEX IF NOT EXISTS idx_tasks_scheduled_task_id ON tasks(scheduled_task_id);
+
+-- 为created_at创建索引
+CREATE INDEX IF NOT EXISTS idx_tasks_created_at ON tasks(created_at);
+
+-- 为namespace和queue创建复合索引
+CREATE INDEX IF NOT EXISTS idx_tasks_namespace_queue ON tasks(namespace, queue);
+
+-- 为namespace和scheduled_task_id创建复合索引
+CREATE INDEX IF NOT EXISTS idx_tasks_namespace_scheduled ON tasks(namespace, scheduled_task_id) WHERE scheduled_task_id IS NOT NULL;
+
+-- 2. 任务运行记录表 (task_runs)
+-- 记录每个消费者组对任务的执行情况
+CREATE TABLE IF NOT EXISTS task_runs (
+    id BIGSERIAL PRIMARY KEY,                     -- 内部主键
+    task_id BIGINT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,  -- 关联任务ID
+    stream_id TEXT NOT NULL,                      -- 冗余存储stream_id方便查询
+    task_name TEXT NOT NULL,                      -- 任务名称（执行的具体任务函数）
+    consumer_group TEXT NOT NULL,                 -- 消费者组名称
+    consumer_name TEXT,                           -- 具体的消费者实例名
+    worker_id TEXT,                               -- Worker ID
+    status TEXT NOT NULL DEFAULT 'pending',       -- 执行状态（pending/running/success/failed/retrying/timeout/skipped）
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,  -- 记录创建时间
+    start_time TIMESTAMPTZ,                       -- 开始执行时间
+    end_time TIMESTAMPTZ,                         -- 结束时间
+    duration_ms BIGINT,                           -- 执行耗时（毫秒）
+    retry_count INT DEFAULT 0,                    -- 重试次数
+    max_retries INT DEFAULT 3,                    -- 最大重试次数
+    error_message TEXT,                           -- 错误信息
+    error_details JSONB,                          -- 详细错误信息（包含堆栈等）
+    result JSONB,                                 -- 执行结果
+    logs TEXT[],                                  -- 执行日志
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP  -- 最后更新时间
+);
+
+-- 为task_id创建索引
+CREATE INDEX IF NOT EXISTS idx_task_runs_task_id ON task_runs(task_id);
+
+-- 为stream_id创建索引
+CREATE INDEX IF NOT EXISTS idx_task_runs_stream_id ON task_runs(stream_id);
+
+-- 为task_name创建索引
+CREATE INDEX IF NOT EXISTS idx_task_runs_task_name ON task_runs(task_name);
+
+-- 为consumer_group创建索引
+CREATE INDEX IF NOT EXISTS idx_task_runs_consumer_group ON task_runs(consumer_group);
+
+-- 为status创建索引
+CREATE INDEX IF NOT EXISTS idx_task_runs_status ON task_runs(status);
+
+-- 为created_at创建索引
+CREATE INDEX IF NOT EXISTS idx_task_runs_created_at ON task_runs(created_at);
+
+-- 创建复合索引优化查询
+CREATE INDEX IF NOT EXISTS idx_task_runs_task_group ON task_runs(task_id, consumer_group);
+CREATE INDEX IF NOT EXISTS idx_task_runs_group_status ON task_runs(consumer_group, status);
+CREATE INDEX IF NOT EXISTS idx_task_runs_stream_group ON task_runs(stream_id, consumer_group);
+
+-- 为了保证同一个任务在同一个消费者组中只有一条运行记录，创建唯一约束
+CREATE UNIQUE INDEX IF NOT EXISTS idx_task_runs_unique_task_group ON task_runs(task_id, consumer_group);
+
+-- 更新时间触发器
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- 为task_runs表创建触发器
+DROP TRIGGER IF EXISTS update_task_runs_updated_at ON task_runs;
+CREATE TRIGGER update_task_runs_updated_at 
+    BEFORE UPDATE ON task_runs 
+    FOR EACH ROW 
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- 3. 创建视图方便查询
+-- 任务执行概览视图
+CREATE OR REPLACE VIEW task_execution_overview AS
+SELECT 
+    t.id,
+    t.stream_id,
+    t.queue,
+    t.namespace,
+    t.scheduled_task_id,
+    t.created_at,
+    COUNT(DISTINCT tr.consumer_group) as consumer_group_count,
+    COUNT(tr.id) as total_runs,
+    COUNT(CASE WHEN tr.status = 'success' THEN 1 END) as success_count,
+    COUNT(CASE WHEN tr.status = 'failed' THEN 1 END) as failed_count,
+    COUNT(CASE WHEN tr.status = 'running' THEN 1 END) as running_count,
+    AVG(tr.duration_ms) as avg_duration_ms,
+    MAX(tr.end_time) as last_execution_time
+FROM tasks t
+LEFT JOIN task_runs tr ON t.id = tr.task_id
+GROUP BY t.id;
+
+-- 消费者组执行统计视图
+CREATE OR REPLACE VIEW consumer_group_stats AS
+SELECT 
+    tr.consumer_group,
+    tr.task_name,
+    t.queue,
+    t.namespace,
+    COUNT(DISTINCT tr.task_id) as total_tasks,
+    COUNT(CASE WHEN tr.status = 'success' THEN 1 END) as success_count,
+    COUNT(CASE WHEN tr.status = 'failed' THEN 1 END) as failed_count,
+    COUNT(CASE WHEN tr.status = 'running' THEN 1 END) as running_count,
+    AVG(tr.duration_ms) as avg_duration_ms,
+    SUM(tr.retry_count) as total_retries,
+    MAX(tr.end_time) as last_activity
+FROM task_runs tr
+JOIN tasks t ON tr.task_id = t.id
+GROUP BY tr.consumer_group, tr.task_name, t.queue, t.namespace;
+
+-- 按命名空间的任务统计视图
+CREATE OR REPLACE VIEW namespace_task_stats AS
+SELECT 
+    t.namespace,
+    t.queue,
+    COUNT(DISTINCT t.id) as total_tasks,
+    COUNT(DISTINCT t.scheduled_task_id) as scheduled_tasks,
+    COUNT(DISTINCT tr.task_name) as unique_task_names,
+    COUNT(DISTINCT tr.consumer_group) as consumer_groups,
+    COUNT(tr.id) as total_runs,
+    COUNT(CASE WHEN tr.status = 'success' THEN 1 END) as success_runs,
+    COUNT(CASE WHEN tr.status = 'failed' THEN 1 END) as failed_runs,
+    AVG(tr.duration_ms) as avg_duration_ms,
+    MIN(t.created_at) as first_task_at,
+    MAX(t.created_at) as last_task_at
+FROM tasks t
+LEFT JOIN task_runs tr ON t.id = tr.task_id
+GROUP BY t.namespace, t.queue;
+
+-- 添加注释
+COMMENT ON TABLE tasks IS '任务基础信息表，存储任务的元数据';
+COMMENT ON TABLE task_runs IS '任务运行记录表，记录每个消费者组对任务的执行情况';
+COMMENT ON COLUMN tasks.stream_id IS 'Redis Stream的消息ID，确保幂等性';
+COMMENT ON COLUMN tasks.namespace IS '命名空间，用于多租户隔离';
+COMMENT ON COLUMN tasks.scheduled_task_id IS '调度任务ID，标识该任务是否由调度器产生';
+COMMENT ON COLUMN tasks.payload IS '任务参数，存储完整的event_data';
+COMMENT ON COLUMN task_runs.task_name IS '具体执行的任务函数名称';
+COMMENT ON COLUMN task_runs.consumer_group IS '消费者组名称，格式如：jettask:QUEUE:queue_name:task_name';
+COMMENT ON COLUMN task_runs.created_at IS '记录创建时间，标记任务何时被消费者接收';
+COMMENT ON COLUMN task_runs.start_time IS '实际开始执行时间，可能与created_at不同';
+COMMENT ON COLUMN task_runs.duration_ms IS '执行耗时（毫秒），由应用层计算';