jettask 0.2.23__py3-none-any.whl → 0.2.24__py3-none-any.whl

jettask/db/base.py

@@ -0,0 +1,137 @@
+"""
+数据库基础配置
+
+使用 SQLAlchemy 2.0 的异步API
+"""
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+from sqlalchemy.orm import declarative_base
+from sqlalchemy.pool import NullPool
+import logging
+
+logger = logging.getLogger(__name__)
+
+# 创建基类
+Base = declarative_base()
+
+# 全局引擎和会话工厂
+_engine = None
+_async_session_factory = None
+
+
+def get_engine(database_url: str, **kwargs):
+    """
+    获取或创建数据库引擎
+
+    Args:
+        database_url: 数据库连接URL（如 postgresql+asyncpg://user:pass@host/db）
+        **kwargs: 其他引擎参数
+
+    Returns:
+        AsyncEngine: 异步数据库引擎
+    """
+    global _engine
+
+    if _engine is None:
+        # 确保使用正确的异步驱动
+        if database_url and 'postgresql://' in database_url:
+            database_url = database_url.replace('postgresql://', 'postgresql+asyncpg://')
+
+        # 默认配置
+        engine_kwargs = {
+            'echo': kwargs.pop('echo', False),
+            'pool_pre_ping': kwargs.pop('pool_pre_ping', True),
+            'poolclass': kwargs.pop('poolclass', NullPool),  # 使用NullPool避免连接池问题
+        }
+        engine_kwargs.update(kwargs)
+
+        _engine = create_async_engine(database_url, **engine_kwargs)
+        logger.info(f"数据库引擎已创建: {database_url.split('@')[-1]}")
+
+    return _engine
+
+
+def get_session_factory(database_url: str = None, **kwargs):
+    """
+    获取或创建会话工厂
+
+    Args:
+        database_url: 数据库连接URL
+        **kwargs: 其他引擎参数
+
+    Returns:
+        async_sessionmaker: 异步会话工厂
+    """
+    global _async_session_factory
+
+    if _async_session_factory is None:
+        if database_url is None:
+            raise ValueError("数据库URL未提供")
+
+        engine = get_engine(database_url, **kwargs)
+        _async_session_factory = async_sessionmaker(
+            engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+
+    return _async_session_factory
+
+
+def get_session(database_url: str = None, **kwargs):
+    """
+    获取数据库会话（上下文管理器）
+
+    Args:
+        database_url: 数据库连接URL
+        **kwargs: 其他引擎参数
+
+    Returns:
+        AsyncSession: 异步数据库会话上下文管理器
+
+    Example:
+        async with get_session(db_url) as session:
+            result = await session.execute(select(Task))
+            tasks = result.scalars().all()
+    """
+    factory = get_session_factory(database_url, **kwargs)
+    return factory()
+
+
+async def init_db(database_url: str, **kwargs):
+    """
+    初始化数据库（创建所有表）
+
+    Args:
+        database_url: 数据库连接URL
+        **kwargs: 其他引擎参数
+
+    Example:
+        await init_db('postgresql+asyncpg://user:pass@localhost/jettask')
+    """
+    # 导入所有模型以注册到 Base.metadata
+    from .models import Task, ScheduledTask, TaskExecutionHistory  # noqa: F401
+
+    engine = get_engine(database_url, **kwargs)
+
+    async with engine.begin() as conn:
+        # 创建所有表
+        await conn.run_sync(Base.metadata.create_all)
+        logger.info("数据库表已创建/更新")
+
+
+async def drop_all(database_url: str, **kwargs):
+    """
+    删除所有表（谨慎使用！）
+
+    Args:
+        database_url: 数据库连接URL
+        **kwargs: 其他引擎参数
+    """
+    # 导入所有模型以注册到 Base.metadata
+    from .models import Task, ScheduledTask, TaskExecutionHistory  # noqa: F401
+
+    engine = get_engine(database_url, **kwargs)
+
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.drop_all)
+        logger.warning("所有数据库表已删除")

jettask/{utils/db_connector.py → db/connector.py}

@@ -60,6 +60,7 @@ from redis.asyncio import BlockingConnectionPool
 from redis.backoff import ExponentialBackoff
 from redis.retry import Retry
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+import asyncpg
 
 logger = logging.getLogger(__name__)
 
@@ -85,6 +86,9 @@ class _PoolRegistry:
     pg_engines: Dict[str, Any] = {}
     pg_session_factories: Dict[str, async_sessionmaker] = {}
 
+    # PostgreSQL asyncpg 连接池缓存（原生asyncpg连接池）
+    asyncpg_pools: Dict[str, Any] = {}
+
     # Redis 客户端实例缓存
     sync_redis_clients: Dict[str, sync_redis.StrictRedis] = {}
     sync_binary_redis_clients: Dict[str, sync_redis.StrictRedis] = {}
@@ -100,6 +104,7 @@ class _PoolRegistry:
         cls.async_binary_redis_pools.clear()
         cls.pg_engines.clear()
         cls.pg_session_factories.clear()
+        cls.asyncpg_pools.clear()
         cls.sync_redis_clients.clear()
         cls.sync_binary_redis_clients.clear()
         cls.async_redis_clients.clear()
@@ -273,6 +278,13 @@ class IdleTrackingBlockingConnectionPool(sync_redis.BlockingConnectionPool):
                 connections_to_keep.append(conn)
                 continue
 
+            # 检查连接是否被标记为 PubSub 连接
+            # 注意：需要外部在创建 PubSub 时调用 mark_as_pubsub() 标记连接
+            if hasattr(conn, '_is_pubsub_connection') and conn._is_pubsub_connection:
+                logger.info(f"跳过 PubSub 连接清理: {id(conn)}")
+                connections_to_keep.append(conn)
+                continue
+
             conn_id = id(conn)
             with self._connection_last_use_lock:
                 last_use = self._connection_last_use.get(conn_id, current_time)
@@ -322,11 +334,11 @@ class IdleTrackingBlockingConnectionPool(sync_redis.BlockingConnectionPool):
                 final_total = len(self._connections)
                 final_available = self.pool.qsize()
                 final_in_use = final_total - final_available
-            logger.info(
-                f"空闲连接清理完成: 清理前 {initial_total} (可用: {initial_available}, 使用中: {initial_in_use}), "
-                f"关闭 {closed_count} 个, "
-                f"剩余 {final_total} (可用: {final_available}, 使用中: {final_in_use})"
-            )
+            # logger.info(
+            #     f"空闲连接清理完成: 清理前 {initial_total} (可用: {initial_available}, 使用中: {initial_in_use}), "
+            #     f"关闭 {closed_count} 个, "
+            #     f"剩余 {final_total} (可用: {final_available}, 使用中: {final_in_use})"
+            # )
 
     def _stop_idle_cleaner(self):
         """停止空闲连接清理线程"""
@@ -473,6 +485,13 @@ class AsyncIdleTrackingBlockingConnectionPool(redis.BlockingConnectionPool):
                 connections_to_keep.append(conn)
                 continue
 
+            # 检查连接是否被标记为 PubSub 连接
+            # 注意：需要外部在创建 PubSub 时调用 mark_as_pubsub() 标记连接
+            if hasattr(conn, '_is_pubsub_connection') and conn._is_pubsub_connection:
+                logger.info(f"跳过 PubSub 连接清理: {id(conn)}")
+                connections_to_keep.append(conn)
+                continue
+
             conn_id = id(conn)
             async with self._connection_last_use_lock:
                 last_use = self._connection_last_use.get(conn_id, current_time)
@@ -579,8 +598,8 @@ def get_sync_redis_pool(
     socket_timeout: int = 60,
     timeout: int = 60,
     health_check_interval: int = 30,
-    max_idle_time: int = 120,
-    idle_check_interval: int = 10,
+    max_idle_time: int = 10,
+    idle_check_interval: int = 1,
     **pool_kwargs
 ) -> IdleTrackingBlockingConnectionPool:
     """
@@ -627,8 +646,8 @@ def get_sync_redis_pool(
     # 选择连接池缓存字典
     pool_cache = _sync_redis_pools if decode_responses else _sync_binary_redis_pools
 
-    # 构建缓存键（包含影响连接的关键参数）
-    cache_key = redis_url
+    # 构建缓存键（包含socket_timeout以区分不同的超时配置）
+    cache_key = f"{redis_url}:socket_timeout={socket_timeout}"
 
     if cache_key not in pool_cache:
         socket_keepalive_options = _get_socket_keepalive_options()
@@ -671,12 +690,12 @@ def get_async_redis_pool(
     decode_responses: bool = True,
     max_connections: int = 200,
     socket_connect_timeout: int = 30,
-    socket_timeout: int = 60,
+    socket_timeout: int | None = None,  # None表示无限等待（支持PubSub长连接）
     socket_keepalive: bool = True,
     health_check_interval: int = 30,
     timeout: int = 60,
-    max_idle_time: int = 120,
-    idle_check_interval: int = 10,
+    max_idle_time: int = 10,
+    idle_check_interval: int = 1,
     **pool_kwargs
 ) -> AsyncIdleTrackingBlockingConnectionPool:
     """
@@ -694,7 +713,7 @@ def get_async_redis_pool(
         decode_responses: 是否解码响应为字符串
         max_connections: 连接池最大连接数（默认200）
         socket_connect_timeout: Socket 连接超时（秒），默认30秒
-        socket_timeout: Socket 读写超时（秒），默认60秒，0表示无限等待
+        socket_timeout: Socket 读写超时（秒），None表示无限等待（支持PubSub），>0表示具体超时时间
         socket_keepalive: 是否启用 socket keepalive
         health_check_interval: 健康检查间隔（秒），默认30秒（推荐30-60秒）
         timeout: 等待可用连接的超时时间（秒），默认60秒
@@ -709,8 +728,10 @@ def get_async_redis_pool(
     # 选择连接池缓存字典
     pool_cache = _async_redis_pools if decode_responses else _async_binary_redis_pools
 
-    # 构建缓存键
-    cache_key = redis_url
+    # 构建缓存键（包含socket_timeout以区分不同的超时配置）
+    cache_key = f"{redis_url}:socket_timeout={socket_timeout}"
+
+    logger.info(f"get_async_redis_pool called: socket_timeout={socket_timeout}, cache_key={cache_key}, exists={cache_key in pool_cache}")
 
     if cache_key not in pool_cache:
         socket_keepalive_options = _get_socket_keepalive_options()
@@ -736,9 +757,10 @@ def get_async_redis_pool(
         if socket_keepalive and socket_keepalive_options:
             pool_params['socket_keepalive_options'] = socket_keepalive_options
 
-        # 添加 socket_timeout（0 表示无限等待）
-        if socket_timeout > 0:
-            pool_params['socket_timeout'] = socket_timeout
+        # 添加 socket_timeout
+        # 注意：None 表示无限等待（适合PubSub），>0 表示具体超时时间
+        # socket_timeout 参数总是会被设置，即使是 None
+        pool_params['socket_timeout'] = socket_timeout
 
         # 合并其他参数
         pool_params.update(pool_kwargs)
@@ -829,7 +851,7 @@ def get_async_redis_pool_for_pubsub(
     获取或创建专门用于 Pub/Sub 的异步 Redis 连接池
 
     Pub/Sub 是长连接，可能长时间没有消息，因此使用特殊配置：
-    - socket_timeout=0 （无限等待，不会因为没有消息而超时）
+    - socket_timeout=None （无限等待，不会因为没有消息而超时）
     - max_connections=10 （Pub/Sub 只需要少量连接）
     - health_check_interval=60 （每60秒主动检查连接健康）
 
@@ -848,7 +870,7 @@ def get_async_redis_pool_for_pubsub(
         decode_responses=decode_responses,
         max_connections=max_connections,
         socket_connect_timeout=30,
-        socket_timeout=0,  # 无限等待！不会因为没有消息而超时
+        socket_timeout=None,  # 无限等待！不会因为没有消息而超时
         socket_keepalive=True,
         health_check_interval=health_check_interval,
         **pool_kwargs
@@ -903,6 +925,85 @@ def get_pg_engine_and_factory(
     return _pg_engines[dsn], _pg_session_factories[dsn]
 
 
+async def get_asyncpg_pool(
+    dsn: str,
+    min_size: int = 2,
+    max_size: int = 10,
+    command_timeout: float = 60.0,
+    timeout: float = 10.0,
+    max_retries: int = 3,
+    retry_delay: int = 5,
+    **pool_kwargs
+) -> asyncpg.Pool:
+    """
+    获取或创建 asyncpg 连接池（全局单例）
+
+    Args:
+        dsn: PostgreSQL 连接 DSN（支持 postgresql:// 或 postgresql+asyncpg:// 格式）
+        min_size: 连接池最小连接数
+        max_size: 连接池最大连接数
+        command_timeout: 命令执行超时（秒）
+        timeout: 连接超时（秒）
+        max_retries: 最大重试次数
+        retry_delay: 重试间隔（秒）
+        **pool_kwargs: 其他连接池参数
+
+    Returns:
+        asyncpg.Pool: asyncpg 连接池
+    """
+    # 将 SQLAlchemy 格式的 DSN 转换为标准 PostgreSQL DSN
+    # postgresql+asyncpg:// -> postgresql://
+    if dsn and '+asyncpg' in dsn:
+        dsn = dsn.replace('+asyncpg', '')
+
+    # 隐藏密码的 DSN 用于日志
+    safe_dsn = _get_safe_pg_dsn(dsn)
+
+    if dsn not in _PoolRegistry.asyncpg_pools:
+        # 重试机制
+        for attempt in range(1, max_retries + 1):
+            try:
+                logger.info(f"正在创建 asyncpg 连接池 (尝试 {attempt}/{max_retries}): {safe_dsn}")
+
+                pool = await asyncpg.create_pool(
+                    dsn,
+                    min_size=min_size,
+                    max_size=max_size,
+                    command_timeout=command_timeout,
+                    timeout=timeout,
+                    **pool_kwargs
+                )
+
+                _PoolRegistry.asyncpg_pools[dsn] = pool
+                logger.info(f"asyncpg 连接池创建成功: {safe_dsn} (min={min_size}, max={max_size})")
+                break
+
+            except Exception as e:
+                logger.error(f"asyncpg 连接池创建失败 (尝试 {attempt}/{max_retries}): {safe_dsn}, 错误: {e}")
+
+                if attempt < max_retries:
+                    logger.info(f"等待 {retry_delay} 秒后重试...")
+                    await asyncio.sleep(retry_delay)
+                else:
+                    # 最后一次尝试失败，抛出异常
+                    logger.error(f"asyncpg 连接池创建失败，已达到最大重试次数 ({max_retries})")
+                    raise
+
+    return _PoolRegistry.asyncpg_pools[dsn]
+
+
+def _get_safe_pg_dsn(dsn: str) -> str:
+    """获取用于日志的安全 DSN（隐藏密码）"""
+    if not dsn:
+        return "None"
+    try:
+        import re
+        # postgresql://user:password@host:port/database -> postgresql://user:***@host:port/database
+        return re.sub(r'://([^:]+):([^@]+)@', r'://\1:***@', dsn)
+    except:
+        return dsn
+
+
 # ============================================================
 # Section 6: 配置和连接器类
 # ============================================================
@@ -1519,8 +1620,9 @@ def get_sync_redis_client(
     # 选择客户端缓存
     client_cache = _sync_redis_clients if decode_responses else _sync_binary_redis_clients
 
-    # 构建缓存键
-    cache_key = redis_url
+    # 构建缓存键（需要包含socket_timeout以匹配pool的缓存键）
+    socket_timeout_val = pool_kwargs.get('socket_timeout', 60)  # 获取socket_timeout，默认60
+    cache_key = f"{redis_url}:socket_timeout={socket_timeout_val}"
 
     if cache_key not in client_cache:
         # 获取连接池（已经是单例）
@@ -1542,7 +1644,7 @@ def get_async_redis_client(
     redis_url: str,
     decode_responses: bool = True,
     max_connections: int = 1000,
-    socket_timeout: int = 60,
+    socket_timeout: int | None = None,  # None表示无限等待，支持PubSub长连接
     **pool_kwargs
 ) -> redis.StrictRedis:
     """
@@ -1552,7 +1654,7 @@ def get_async_redis_client(
         redis_url: Redis 连接 URL
         decode_responses: 是否解码响应为字符串
         max_connections: 连接池最大连接数
-        socket_timeout: Socket 读写超时（秒）
+        socket_timeout: Socket 读写超时（秒），None表示无限等待
         **pool_kwargs: 其他连接池参数
 
     Returns:
@@ -1565,8 +1667,8 @@ def get_async_redis_client(
     # 选择客户端缓存
     client_cache = _async_redis_clients if decode_responses else _async_binary_redis_clients
 
-    # 构建缓存键
-    cache_key = redis_url
+    # 构建缓存键（包含socket_timeout以匹配pool的缓存键）
+    cache_key = f"{redis_url}:socket_timeout={socket_timeout}"
 
     if cache_key not in client_cache:
         # 获取连接池（已经是单例）
@@ -1606,10 +1708,12 @@ __all__ = [
     'get_async_redis_pool',
     'get_async_redis_pool_for_pubsub',  # 专门用于 Pub/Sub 的连接池
     'get_pg_engine_and_factory',
+    'get_asyncpg_pool',  # asyncpg 原生连接池
 
     # 客户端实例函数（推荐使用）
     'get_sync_redis_client',
     'get_async_redis_client',
+    'get_dual_mode_async_redis_client',  # 双模式客户端（文本+二进制）
 
     # 缓存清理
     'clear_all_cache',

jettask/db/models/__init__.py

@@ -0,0 +1,16 @@
+"""
+数据库模型定义
+
+所有表的 SQLAlchemy 模型定义
+"""
+
+from .task import Task
+from .task_run import TaskRun
+from .scheduled_task import ScheduledTask, TaskExecutionHistory
+
+__all__ = [
+    'Task',
+    'TaskRun',
+    'ScheduledTask',
+    'TaskExecutionHistory',
+]

jettask/db/models/scheduled_task.py

@@ -0,0 +1,196 @@
+"""
+ScheduledTask 和 TaskExecutionHistory 模型
+
+对应 scheduled_tasks 和 task_execution_history 表，用于定时任务调度
+"""
+from sqlalchemy import (
+    Column, BigInteger, String, Integer, Text, Boolean,
+    TIMESTAMP, Index, Numeric, ForeignKey
+)
+from sqlalchemy.dialects.postgresql import JSONB
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+
+from ..base import Base
+
+
+class ScheduledTask(Base):
+    """
+    定时任务表
+
+    定时任务以 queue 为核心，定期向指定队列发送消息
+    """
+    __tablename__ = 'scheduled_tasks'
+
+    # 主键
+    id = Column(BigInteger, primary_key=True, autoincrement=True, comment='自增主键')
+
+    # 唯一标识
+    scheduler_id = Column(
+        String(255),
+        nullable=False,
+        unique=True,
+        comment='任务的唯一标识符（用于去重）'
+    )
+
+    # 任务类型
+    task_type = Column(
+        String(50),
+        nullable=False,
+        comment='任务类型: cron, interval, once'
+    )
+
+    # 任务执行相关
+    queue_name = Column(String(100), nullable=False, comment='目标队列名')
+    namespace = Column(String(100), default='default', comment='命名空间')
+    task_args = Column(JSONB, default=[], comment='任务参数')
+    task_kwargs = Column(JSONB, default={}, comment='任务关键字参数')
+
+    # 调度相关
+    cron_expression = Column(String(100), comment='cron表达式 (task_type=cron时使用)')
+    interval_seconds = Column(Numeric(10, 2), comment='间隔秒数 (task_type=interval时使用)')
+    next_run_time = Column(TIMESTAMP(timezone=True), comment='下次执行时间')
+    last_run_time = Column(TIMESTAMP(timezone=True), comment='上次执行时间')
+
+    # 状态和控制
+    enabled = Column(Boolean, default=True, comment='是否启用')
+    max_retries = Column(Integer, default=3, comment='最大重试次数')
+    retry_delay = Column(Integer, default=60, comment='重试延迟(秒)')
+    timeout = Column(Integer, default=300, comment='任务超时时间(秒)')
+    priority = Column(Integer, comment='任务优先级 (1=最高, 数字越大优先级越低，NULL=默认最低)')
+
+    # 元数据 (使用 column name override 避免与 SQLAlchemy 的 metadata 属性冲突)
+    description = Column(Text, comment='任务描述')
+    tags = Column(JSONB, default=[], comment='标签')
+    task_metadata = Column('metadata', JSONB, default={}, comment='额外元数据')
+
+    # 时间戳
+    created_at = Column(
+        TIMESTAMP(timezone=True),
+        default=datetime.utcnow,
+        comment='创建时间'
+    )
+    updated_at = Column(
+        TIMESTAMP(timezone=True),
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+        comment='更新时间'
+    )
+
+    # 索引
+    __table_args__ = (
+        Index('idx_scheduled_tasks_next_run', 'next_run_time', postgresql_where=(enabled == True)),  # noqa: E712
+        Index('idx_scheduled_tasks_task_type', 'task_type'),
+        Index('idx_scheduled_tasks_queue', 'queue_name'),
+        Index('idx_scheduled_tasks_enabled', 'enabled'),
+        Index('idx_scheduled_tasks_scheduler_id', 'scheduler_id', unique=True),
+    )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典"""
+        return {
+            'id': self.id,
+            'scheduler_id': self.scheduler_id,
+            'task_type': self.task_type,
+            'queue_name': self.queue_name,
+            'namespace': self.namespace,
+            'task_args': self.task_args,
+            'task_kwargs': self.task_kwargs,
+            'cron_expression': self.cron_expression,
+            'interval_seconds': float(self.interval_seconds) if self.interval_seconds else None,
+            'next_run_time': self.next_run_time.isoformat() if self.next_run_time else None,
+            'last_run_time': self.last_run_time.isoformat() if self.last_run_time else None,
+            'enabled': self.enabled,
+            'max_retries': self.max_retries,
+            'retry_delay': self.retry_delay,
+            'timeout': self.timeout,
+            'priority': self.priority,
+            'description': self.description,
+            'tags': self.tags,
+            'metadata': self.task_metadata,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None,
+        }
+
+    def __repr__(self) -> str:
+        return f"<ScheduledTask(id={self.id}, scheduler_id='{self.scheduler_id}', queue='{self.queue_name}', type='{self.task_type}')>"
+
+
+class TaskExecutionHistory(Base):
+    """
+    任务执行历史表
+
+    记录定时任务的执行历史
+    """
+    __tablename__ = 'task_execution_history'
+
+    # 主键
+    id = Column(BigInteger, primary_key=True, autoincrement=True)
+
+    # 关联任务
+    task_id = Column(
+        BigInteger,
+        nullable=False,
+        comment='关联的任务ID（外键到 scheduled_tasks.id）'
+    )
+    event_id = Column(String(255), nullable=False, comment='执行事件ID')
+
+    # 执行信息
+    scheduled_time = Column(
+        TIMESTAMP(timezone=True),
+        nullable=False,
+        comment='计划执行时间'
+    )
+    started_at = Column(TIMESTAMP(timezone=True), comment='实际开始时间')
+    finished_at = Column(TIMESTAMP(timezone=True), comment='完成时间')
+
+    # 执行结果
+    status = Column(
+        String(50),
+        nullable=False,
+        comment='状态: pending, running, success, failed, timeout'
+    )
+    result = Column(JSONB, comment='执行结果')
+    error_message = Column(Text, comment='错误信息')
+    retry_count = Column(Integer, default=0, comment='重试次数')
+
+    # 性能指标
+    duration_ms = Column(Integer, comment='执行耗时(毫秒)')
+    worker_id = Column(String(100), comment='执行的worker ID')
+
+    # 时间戳
+    created_at = Column(
+        TIMESTAMP(timezone=True),
+        default=datetime.utcnow,
+        comment='创建时间'
+    )
+
+    # 索引
+    __table_args__ = (
+        Index('idx_task_history_task_id', 'task_id'),
+        Index('idx_task_history_event_id', 'event_id'),
+        Index('idx_task_history_status', 'status'),
+        Index('idx_task_history_scheduled', 'scheduled_time'),
+        Index('idx_task_history_created', 'created_at'),
+    )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典"""
+        return {
+            'id': self.id,
+            'task_id': self.task_id,
+            'event_id': self.event_id,
+            'scheduled_time': self.scheduled_time.isoformat() if self.scheduled_time else None,
+            'started_at': self.started_at.isoformat() if self.started_at else None,
+            'finished_at': self.finished_at.isoformat() if self.finished_at else None,
+            'status': self.status,
+            'result': self.result,
+            'error_message': self.error_message,
+            'retry_count': self.retry_count,
+            'duration_ms': self.duration_ms,
+            'worker_id': self.worker_id,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+        }
+
+    def __repr__(self) -> str:
+        return f"<TaskExecutionHistory(id={self.id}, task_id={self.task_id}, event_id='{self.event_id}', status='{self.status}')>"