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

jettask/core/cli.py

@@ -474,6 +474,158 @@ def scheduler(task_center, interval, batch_size, check_interval, debug):
     except KeyboardInterrupt:
         click.echo("\nShutdown complete")
 
+@cli.command()
+@click.option('--port', default=5173, 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', is_flag=True, help='构建生产版本而不是启动开发服务器')
+def frontend(port, host, auto_install, force_install, build):
+    """启动 WebUI 前端界面
+    
+    自动检测环境并启动前端开发服务器：
+    1. 检查 Node.js 和 npm 是否安装
+    2. 自动安装缺失的依赖
+    3. 启动开发服务器或构建生产版本
+    
+    示例：
+      # 启动开发服务器（默认）
+      jettask frontend
+      
+      # 指定端口
+      jettask frontend --port 3000
+      
+      # 构建生产版本
+      jettask frontend --build
+      
+      # 强制重新安装依赖
+      jettask frontend --force-install
+    """
+    import subprocess
+    import shutil
+    from pathlib import Path
+    
+    # 获取前端目录路径
+    frontend_dir = Path(__file__).parent.parent / "webui" / "frontend"
+    if not frontend_dir.exists():
+        click.echo(f"错误：前端目录不存在: {frontend_dir}", err=True)
+        sys.exit(1)
+    
+    # 检查 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:
+        if build:
+            # 构建生产版本
+            click.echo("\n正在构建生产版本...")
+            subprocess.run([npm_cmd, 'run', 'build'], check=True)
+            
+            # 显示构建结果
+            dist_dir = frontend_dir.parent / "static" / "dist"
+            if dist_dir.exists():
+                click.echo(f"\n✓ 构建完成！输出目录: {dist_dir}")
+                # 统计文件
+                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"  - 文件数量: {file_count}")
+                click.echo(f"  - 总大小: {total_size / 1024 / 1024:.2f} MB")
+            else:
+                click.echo("警告：构建完成但未找到输出目录")
+        else:
+            # 启动开发服务器
+            click.echo(f"\n正在启动前端开发服务器...")
+            click.echo(f"  - 地址: http://{host}:{port}")
+            click.echo(f"  - 本地访问: http://localhost:{port}")
+            click.echo("\n按 Ctrl+C 停止服务器\n")
+            
+            # 构建启动命令
+            cmd = [npm_cmd, 'run', 'dev']
+            if host != 'localhost':
+                cmd.extend(['--', '--host', host])
+            if port != 5173:
+                cmd.extend(['--port', str(port)])
+            
+            # 启动开发服务器
+            process = subprocess.Popen(cmd)
+            process.wait()
+    except subprocess.CalledProcessError as e:
+        click.echo(f"错误：命令执行失败 - {e}", err=True)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        click.echo("\n停止前端服务器")
+        if 'process' in locals():
+            process.terminate()
+            process.wait()
+
 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 '执行耗时（毫秒），由应用层计算';

jettask/pg_consumer/sql/migrate_to_new_structure.sql

@@ -0,0 +1,179 @@
+-- 数据迁移脚本
+-- 从旧的单表结构迁移到新的双表结构
+
+BEGIN;
+
+-- 1. 先备份原表（如果存在）
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'tasks') THEN
+        -- 如果tasks表已存在，重命名为备份表
+        IF NOT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'tasks_backup') THEN
+            ALTER TABLE tasks RENAME TO tasks_backup;
+        ELSE
+            -- 如果备份表已存在，创建带时间戳的备份
+            EXECUTE format('ALTER TABLE tasks RENAME TO tasks_backup_%s', 
+                          to_char(now(), 'YYYYMMDD_HH24MISS'));
+        END IF;
+    END IF;
+END $$;
+
+-- 2. 执行创建新表的SQL（引用create_new_tables.sql的内容）
+-- 注意：在实际使用时，应该先运行create_new_tables.sql
+
+-- 3. 如果有旧数据，进行数据迁移
+DO $$
+BEGIN
+    -- 检查是否有备份表
+    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'tasks_backup') THEN
+        -- 迁移任务基础信息到新的tasks表
+        INSERT INTO tasks (
+            stream_id,
+            queue,
+            task_name,
+            task_type,
+            payload,
+            priority,
+            created_at,
+            scheduled_at,
+            status,
+            source,
+            metadata
+        )
+        SELECT 
+            COALESCE(task_id, 'unknown-' || id::text) as stream_id,  -- 使用task_id作为stream_id
+            COALESCE(queue_name, 'default') as queue,
+            COALESCE(task_name, 'unknown') as task_name,
+            task_type,
+            COALESCE(task_data, '{}'::jsonb) as payload,
+            COALESCE(priority, 0) as priority,
+            created_at,
+            trigger_time as scheduled_at,
+            CASE 
+                WHEN status IN ('pending', 'running', 'completed', 'failed') THEN status
+                WHEN status = 'success' THEN 'completed'
+                ELSE 'pending'
+            END as status,
+            'migration' as source,
+            jsonb_build_object(
+                'migrated_at', now(),
+                'original_id', id,
+                'original_status', status
+            ) as metadata
+        FROM tasks_backup
+        ON CONFLICT (stream_id) DO NOTHING;  -- 避免重复
+
+        -- 迁移执行记录到task_runs表
+        -- 由于旧表是单表结构，我们为每个任务创建一条运行记录
+        INSERT INTO task_runs (
+            task_id,
+            stream_id,
+            consumer_group,
+            consumer_name,
+            worker_id,
+            status,
+            start_time,
+            end_time,
+            retry_count,
+            error_message,
+            result
+        )
+        SELECT 
+            t.id as task_id,
+            t.stream_id,
+            'default_group' as consumer_group,  -- 默认消费者组
+            tb.consumer as consumer_name,
+            tb.consumer as worker_id,
+            CASE 
+                WHEN tb.status = 'success' THEN 'success'
+                WHEN tb.status IN ('failed', 'error') THEN 'failed'
+                WHEN tb.status = 'running' THEN 'running'
+                WHEN tb.status = 'timeout' THEN 'timeout'
+                ELSE 'pending'
+            END as status,
+            tb.started_at as start_time,
+            tb.completed_at as end_time,
+            COALESCE(tb.retry_count, 0) as retry_count,
+            tb.error as error_message,
+            tb.result
+        FROM tasks_backup tb
+        JOIN tasks t ON t.stream_id = COALESCE(tb.task_id, 'unknown-' || tb.id::text)
+        WHERE tb.status IS NOT NULL;
+
+        RAISE NOTICE 'Data migration completed successfully';
+    ELSE
+        RAISE NOTICE 'No backup table found, skipping data migration';
+    END IF;
+END $$;
+
+-- 4. 创建兼容性视图（可选）
+-- 如果有代码依赖旧的表结构，可以创建视图提供兼容性
+CREATE OR REPLACE VIEW tasks_legacy AS
+SELECT 
+    t.id,
+    t.stream_id as task_id,
+    t.queue as queue_name,
+    t.task_name,
+    t.task_type,
+    t.payload as task_data,
+    t.priority,
+    tr.consumer_name as consumer,
+    tr.status,
+    tr.start_time as started_at,
+    tr.end_time as completed_at,
+    tr.retry_count,
+    tr.error_message as error,
+    tr.result,
+    t.created_at,
+    tr.updated_at,
+    t.scheduled_at as trigger_time
+FROM tasks t
+LEFT JOIN task_runs tr ON t.id = tr.task_id 
+    AND tr.consumer_group = 'default_group';  -- 兼容旧代码，只显示默认组
+
+-- 5. 更新序列（如果需要）
+DO $$
+DECLARE
+    max_id BIGINT;
+BEGIN
+    -- 获取最大ID
+    SELECT COALESCE(MAX(id), 0) INTO max_id FROM tasks;
+    -- 更新序列
+    IF max_id > 0 THEN
+        EXECUTE format('ALTER SEQUENCE tasks_id_seq RESTART WITH %s', max_id + 1);
+    END IF;
+    
+    SELECT COALESCE(MAX(id), 0) INTO max_id FROM task_runs;
+    IF max_id > 0 THEN
+        EXECUTE format('ALTER SEQUENCE task_runs_id_seq RESTART WITH %s', max_id + 1);
+    END IF;
+END $$;
+
+COMMIT;
+
+-- 6. 验证迁移结果
+SELECT 
+    'Tasks Table' as table_name,
+    COUNT(*) as row_count
+FROM tasks
+UNION ALL
+SELECT 
+    'Task Runs Table' as table_name,
+    COUNT(*) as row_count
+FROM task_runs
+UNION ALL
+SELECT 
+    'Original Backup Table' as table_name,
+    COUNT(*) as row_count
+FROM tasks_backup
+WHERE EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'tasks_backup');
+
+-- 显示迁移统计
+SELECT 
+    'Migration Summary' as info,
+    jsonb_build_object(
+        'total_tasks', (SELECT COUNT(*) FROM tasks),
+        'total_runs', (SELECT COUNT(*) FROM task_runs),
+        'unique_consumer_groups', (SELECT COUNT(DISTINCT consumer_group) FROM task_runs),
+        'migration_time', now()
+    ) as details;