jettask 0.2.1__py3-none-any.whl → 0.2.4__py3-none-any.whl

jettask/core/worker_scanner.py

@@ -36,81 +36,81 @@ class WorkerScanner:
         self._scan_counter = 0
         self._partial_check_interval = 10  # 每10次扫描做部分检查
         
-    async def ensure_initialized(self):
-        """确保 Sorted Set 已初始化并保持一致"""
-        current_time = time.time()
+    # async def ensure_initialized(self):
+    #     """确保 Sorted Set 已初始化并保持一致"""
+    #     current_time = time.time()
         
-        # 首次初始化或定期完整同步
-        if not self._initialized or (current_time - self._last_full_sync > self._full_sync_interval):
-            await self._full_sync()
-            self._initialized = True
-            self._last_full_sync = current_time
+    #     # 首次初始化或定期完整同步
+    #     if not self._initialized or (current_time - self._last_full_sync > self._full_sync_interval):
+    #         await self._full_sync()
+    #         self._initialized = True
+    #         self._last_full_sync = current_time
             
-    async def _full_sync(self):
-        """完整同步 Hash 和 Sorted Set"""
-        try:
-            logger.debug("Starting full synchronization of ACTIVE_WORKERS")
+    # async def _full_sync(self):
+    #     """完整同步 Hash 和 Sorted Set"""
+    #     try:
+    #         logger.debug("Starting full synchronization of ACTIVE_WORKERS")
             
-            # 1. 收集所有活跃 worker 的 Hash 数据
-            pattern = f"{self.redis_prefix}:WORKER:*"
-            hash_workers = {}
+    #         # 1. 收集所有活跃 worker 的 Hash 数据
+    #         pattern = f"{self.redis_prefix}:WORKER:*"
+    #         hash_workers = {}
             
-            async for key in self.async_redis.scan_iter(match=pattern, count=100):
-                if ':HISTORY:' not in key and ':REUSE:' not in key:
-                    worker_id = key.split(':')[-1]
-                    worker_data = await self.async_redis.hgetall(key)
+    #         async for key in self.async_redis.scan_iter(match=pattern, count=100):
+    #             if ':HISTORY:' not in key and ':REUSE:' not in key:
+    #                 worker_id = key.split(':')[-1]
+    #                 worker_data = await self.async_redis.hgetall(key)
                     
-                    if worker_data and worker_data.get('is_alive', 'true').lower() == 'true':
-                        try:
-                            heartbeat = float(worker_data.get('last_heartbeat', 0))
-                            hash_workers[worker_id] = heartbeat
-                        except (ValueError, TypeError):
-                            continue
+    #                 if worker_data and worker_data.get('is_alive', 'true').lower() == 'true':
+    #                     try:
+    #                         heartbeat = float(worker_data.get('last_heartbeat', 0))
+    #                         hash_workers[worker_id] = heartbeat
+    #                     except (ValueError, TypeError):
+    #                         continue
             
-            # 2. 获取 Sorted Set 中的数据
-            zset_workers = await self.async_redis.zrange(
-                self.active_workers_key, 0, -1, withscores=True
-            )
-            zset_dict = {worker_id: score for worker_id, score in zset_workers}
+    #         # 2. 获取 Sorted Set 中的数据
+    #         zset_workers = await self.async_redis.zrange(
+    #             self.active_workers_key, 0, -1, withscores=True
+    #         )
+    #         zset_dict = {worker_id: score for worker_id, score in zset_workers}
             
-            # 3. 计算差异
-            hash_ids = set(hash_workers.keys())
-            zset_ids = set(zset_dict.keys())
+    #         # 3. 计算差异
+    #         hash_ids = set(hash_workers.keys())
+    #         zset_ids = set(zset_dict.keys())
             
-            to_add = hash_ids - zset_ids  # Hash有但ZSet无
-            to_remove = zset_ids - hash_ids  # ZSet有但Hash无
-            to_update = {}  # 时间戳不一致的
+    #         to_add = hash_ids - zset_ids  # Hash有但ZSet无
+    #         to_remove = zset_ids - hash_ids  # ZSet有但Hash无
+    #         to_update = {}  # 时间戳不一致的
             
-            for worker_id in hash_ids & zset_ids:
-                if abs(hash_workers[worker_id] - zset_dict[worker_id]) > 0.1:
-                    to_update[worker_id] = hash_workers[worker_id]
+    #         for worker_id in hash_ids & zset_ids:
+    #             if abs(hash_workers[worker_id] - zset_dict[worker_id]) > 0.1:
+    #                 to_update[worker_id] = hash_workers[worker_id]
             
-            # 4. 批量修复
-            if to_add or to_remove or to_update:
-                pipeline = self.async_redis.pipeline()
+    #         # 4. 批量修复
+    #         if to_add or to_remove or to_update:
+    #             pipeline = self.async_redis.pipeline()
                 
-                if to_add:
-                    members = {worker_id: hash_workers[worker_id] for worker_id in to_add}
-                    pipeline.zadd(self.active_workers_key, members)
+    #             if to_add:
+    #                 members = {worker_id: hash_workers[worker_id] for worker_id in to_add}
+    #                 pipeline.zadd(self.active_workers_key, members)
                     
-                if to_remove:
-                    pipeline.zrem(self.active_workers_key, *to_remove)
+    #             if to_remove:
+    #                 pipeline.zrem(self.active_workers_key, *to_remove)
                     
-                if to_update:
-                    pipeline.zadd(self.active_workers_key, to_update)
+    #             if to_update:
+    #                 pipeline.zadd(self.active_workers_key, to_update)
                     
-                await pipeline.execute()
-                logger.info(f"Full sync: +{len(to_add)}, -{len(to_remove)}, ~{len(to_update)}")
+    #             await pipeline.execute()
+    #             logger.info(f"Full sync: +{len(to_add)}, -{len(to_remove)}, ~{len(to_update)}")
                 
-        except Exception as e:
-            logger.error(f"Full sync failed: {e}")
+    #     except Exception as e:
+    #         logger.error(f"Full sync failed: {e}")
     
     async def scan_timeout_workers(self) -> List[Dict]:
         """
         快速扫描超时的 worker - O(log N) 复杂度
         注意：需要考虑每个worker自己的heartbeat_timeout
         """
-        await self.ensure_initialized()
+        # await self.ensure_initialized()
         
         # 定期部分检查
         self._scan_counter += 1

jettask/executors/asyncio.py

@@ -13,9 +13,25 @@ from collections import defaultdict
 from .base import BaseExecutor
 import random
 from ..exceptions import RetryableError
+from ..core.enums import TaskStatus
 
 logger = logging.getLogger('app')
 
+# Lua脚本：原子地更新Redis hash中的最大值
+UPDATE_MAX_OFFSET_LUA = """
+local hash_key = KEYS[1]
+local field = KEYS[2] 
+local new_value = tonumber(ARGV[1])
+
+local current = redis.call('HGET', hash_key, field)
+if current == false or tonumber(current) < new_value then
+    redis.call('HSET', hash_key, field, new_value)
+    return 1
+else
+    return 0
+end
+"""
+
 # Try to use uvloop for better performance
 try:
     import uvloop
@@ -116,11 +132,11 @@ class AsyncioExecutor(BaseExecutor):
                 
         return self.pending_cache.get(queue, 0)
     
-    async def _quick_ack(self, queue: str, event_id: str, group_name: str = None):
-        """Quick ACK with unified pipeline management"""
+    async def _quick_ack(self, queue: str, event_id: str, group_name: str = None, offset: int = None):
+        """Quick ACK with unified pipeline management and offset tracking"""
         # 如果没有提供group_name，使用queue作为默认值（兼容旧代码）
         group_name = group_name or queue
-        self.pending_acks.append((queue, event_id, group_name))
+        self.pending_acks.append((queue, event_id, group_name, offset))
         current_time = time.time()
         
         # 检查是否需要刷新统一 Pipeline
@@ -147,16 +163,44 @@ class AsyncioExecutor(BaseExecutor):
         # 1. 处理 ACK 操作（使用二进制客户端）
         if self.pending_acks:
             acks_by_queue_group = defaultdict(lambda: defaultdict(list))
+            offset_updates = []  # 收集需要更新的offset
+            
+            # 按照 queue+group_name 分组，记录每个组的最大offset
+            max_offsets = {}  # {(queue, group_name): max_offset}
+            
             for item in self.pending_acks:
-                if len(item) == 3:
+                print(f'{item=}')
+                if len(item) == 4:
+                    queue, event_id, group_name, offset = item
+                elif len(item) == 3:
                     queue, event_id, group_name = item
+                    offset = None
                 else:
                     queue, event_id = item
                     group_name = queue
+                    offset = None
                 
                 prefixed_queue = self._get_prefixed_queue_cached(queue)
                 acks_by_queue_group[prefixed_queue][group_name].append(event_id)
+                
+                # 收集offset更新信息（只记录最大值）
+                if group_name and offset is not None:
+                    key = (queue, group_name)
+                    if key not in max_offsets or offset > max_offsets[key]:
+                        max_offsets[key] = offset
+            
+            logger.info(f'{max_offsets=}')
+            # 处理offset更新（使用Lua脚本确保原子性和最大值约束）
+            if max_offsets:
+                task_offset_key = f"{self.prefix}:TASK_OFFSETS"
+                for (queue, group_name), offset in max_offsets.items():
+                    task_field = f"{queue}:{group_name}"
+                    
+                    # 使用Lua脚本原子地更新最大offset
+                    pipeline.eval(UPDATE_MAX_OFFSET_LUA, 2, task_offset_key, task_field, offset)
+                    operations_count += 1
             
+            # 执行stream ACK
             for prefixed_queue, groups in acks_by_queue_group.items():
                 for group_name, event_ids in groups.items():
                     stream_key = prefixed_queue.encode() if isinstance(prefixed_queue, str) else prefixed_queue
@@ -164,7 +208,7 @@ class AsyncioExecutor(BaseExecutor):
                     batch_bytes = [b.encode() if isinstance(b, str) else b for b in event_ids]
                     
                     # 添加到统一 pipeline
-                    logger.info(f'准备ack {batch_bytes=}')
+                    # logger.info(f'准备ack {batch_bytes=} {stream_key=} {group_key}')
                     pipeline.xack(stream_key, group_key, *batch_bytes)
                     operations_count += 1
             
@@ -173,8 +217,10 @@ class AsyncioExecutor(BaseExecutor):
         # 2. 处理任务信息更新（Hash）
         task_change_events = []  # 收集变更的任务ID
         if self.task_info_updates:
-            for event_id, updates in self.task_info_updates.items():
-                key = f"{self.prefix}:TASK:{event_id}".encode()  # 转为 bytes
+            for event_key, updates in self.task_info_updates.items():
+                # event_key 可能是 "event_id" 或 "event_id:task_name"（广播模式）
+                # key格式: jettask:TASK:event_id:group_name
+                key = f"{self.prefix}:TASK:{event_key}".encode()  # 转为 bytes
                 if updates:
                     # 将更新的值编码为 bytes
                     encoded_updates = {k.encode(): v.encode() if isinstance(v, str) else v for k, v in updates.items()}
@@ -182,20 +228,22 @@ class AsyncioExecutor(BaseExecutor):
                     pipeline.expire(key, 3600)
                     operations_count += 2
                     
-                    # 收集变更的任务ID
-                    task_change_events.append(event_id)
+                    # 收集变更的任务ID（包含完整的key路径）
+                    # event_key 可能是 "event_id" 或 "event_id:task_name"（广播模式）
+                    # 发送完整的task_id，例如 "jettask:TASK:1756956517980-0:jettask:QUEUE:queue_name:task_name"
+                    full_task_id = f"{self.prefix}:TASK:{event_key}"
+                    task_change_events.append(full_task_id)
             
             # 发送变更事件到专门的 Stream 队列
-            if task_change_events:
-                change_stream_key = f"{self.prefix}:TASK_CHANGES".encode()
-                for event_id in task_change_events:
-                    # 只发送事件ID
-                    change_data = {
-                        b'event_id': event_id.encode() if isinstance(event_id, str) else event_id
-                    }
-                    pipeline.xadd(change_stream_key, change_data, maxlen=10000)  # 保留最近10000条变更
-                    operations_count += 1
-            
+            change_stream_key = f"{self.prefix}:TASK_CHANGES".encode()
+            for task_id in task_change_events:
+                # 发送完整的task_id（包含前缀）
+                change_data = {
+                    b'id': task_id.encode() if isinstance(task_id, str) else task_id
+                }
+                pipeline.xadd(change_stream_key, change_data, maxlen=1000000)  # 保留最近100000条变更
+                operations_count += 1
+        
             self.task_info_updates.clear()
         
         # 3. 处理统计信息（如果有）
@@ -279,19 +327,27 @@ class AsyncioExecutor(BaseExecutor):
         
     async def logic(self, semaphore: asyncio.Semaphore, event_id: str, event_data: dict, queue: str, routing: dict = None, consumer: str = None, group_name: str = None, **kwargs):
         """Process a single task"""
-        # 初始化所有变量，避免在 finally 块中未定义
-        execution_start_time = time.time()
-        status = "error"  # 默认状态
+        status = "success"  # 默认状态
         exception = None
         error_msg = None
         ret = None
         task = None  # 初始化 task 变量
         args = ()    # 初始化参数
         kwargs_inner = {}  # 初始化关键字参数（避免与函数参数 kwargs 冲突）
+        # print(f'{group_name=}')
+        # 尽早初始化status_key，避免在finally块中未定义
+        # 使用传入的group_name参数，如果没有则使用queue作为默认值
+        status_key = f"{event_id}:{group_name}"  # 组合key
         
         # 获取任务名称（尽早获取，以便设置日志上下文）
-        task_name = event_data.get("_task_name") or event_data.get("name", "unknown")
-        
+        # 使用_task_name字段（由listen_event_by_task设置）
+        task_name = event_data.get("_task_name") or event_data.get("name")
+        # print(f'{event_data=}')
+        # 如果消息中没有task_name，记录错误并返回
+        if not task_name:
+            logger.error(f"No _task_name in event_data for event {event_id}")
+            # 返回，不处理没有task_name的消息
+            return
         # 设置任务日志上下文 - 包含整个任务处理流程
         async with TaskContextManager(
             event_id=event_id,
@@ -328,10 +384,23 @@ class AsyncioExecutor(BaseExecutor):
                     logger.error(f"No task name found! event_data keys: {list(event_data.keys())}, event_id: {event_id}")
                 
                 task = self.app.get_task_by_name(task_name)
+                
+                # status_key已经在方法开头初始化过了
+                
                 if not task:
-                    exception = f"{task_name=} {queue=} {routing=} 未绑定任何task"
+                    exception = f"{task_name=} {queue=} {event_data=} 未绑定任何task"
                     logger.error(exception)
-                    await self._quick_ack(queue, event_id, group_name)
+                    # 从 event_data 中获取 offset
+                    offset = None
+                    if isinstance(event_data, dict):
+                        offset = event_data.get('offset')
+                        if offset is not None:
+                            try:
+                                offset = int(offset)
+                            except (ValueError, TypeError):
+                                offset = None
+                    
+                    await self._quick_ack(queue, event_id, group_name, offset)
                     
                     # 任务不存在时也记录started_at（使用当前时间）
                     current_time = time.time()
@@ -339,14 +408,13 @@ class AsyncioExecutor(BaseExecutor):
                     trigger_time_float = float(event_data.get('trigger_time', current_time))
                     duration = current_time - trigger_time_float
                     # 使用Hash更新
-                    self.task_info_updates[event_id] = {
-                        "status": "error",
+                    self.task_info_updates[status_key] = {
+                        "status": TaskStatus.ERROR.value,
                         "exception": exception,
                         "started_at": str(current_time),
                         "completed_at": str(current_time),
                         "duration": str(duration),
                         "consumer": consumer,
-                        "result": "null"  # 任务不存在时没有结果
                     }
                     # 使用统一的 pipeline 刷新
                     await self._flush_all_buffers()
@@ -357,25 +425,25 @@ class AsyncioExecutor(BaseExecutor):
                 # 重置状态为 success（默认是 error）
                 status = "success"
                 
-                # 更新执行开始时间（之前已经初始化过）
-                execution_start_time = time.time()
-                
                 # 获取参数（现在直接是对象，不需要反序列化）
                 args = event_data.get("args", ()) or ()
                 
                 # 统一处理kwargs（现在直接是对象，不需要反序列化）
                 kwargs_inner = event_data.get("kwargs", {}) or {}
                 
-                # 对于广播消息，检查是否需要提取特定字段作为参数
-                if event_data.get("_broadcast"):
-                    # 如果消息包含 event_type 和 customer_data，将它们作为参数传递
-                    if "event_type" in event_data and "customer_data" in event_data:
-                        # 将这些字段作为位置参数传递，其他字段作为kwargs
-                        args = (event_data["event_type"], event_data["customer_data"])
-                        # 保留其他字段在kwargs中，但排除已作为args的字段
-                        broadcast_kwargs = {k: v for k, v in event_data.items() 
-                                          if k not in ["event_type", "customer_data", "_broadcast", "_target_tasks", "_timestamp", "trigger_time", "name", "_task_name"]}
-                        kwargs_inner.update(broadcast_kwargs)
+                # 如果event_data中有scheduled_task_id，添加到kwargs中供TaskContext使用
+                if 'scheduled_task_id' in event_data:
+                    kwargs_inner['__scheduled_task_id'] = event_data['scheduled_task_id']
+                
+                # 检查是否需要提取特定字段作为参数
+                # 如果消息包含 event_type 和 customer_data，将它们作为参数传递
+                if "event_type" in event_data and "customer_data" in event_data:
+                    # 将这些字段作为位置参数传递，其他字段作为kwargs
+                    args = (event_data["event_type"], event_data["customer_data"])
+                    # 保留其他字段在kwargs中，但排除已作为args的字段
+                    extra_kwargs = {k: v for k, v in event_data.items() 
+                                  if k not in ["event_type", "customer_data", "_broadcast", "_target_tasks", "_timestamp", "trigger_time", "name", "_task_name"]}
+                    kwargs_inner.update(extra_kwargs)
                 
                 # Execute lifecycle methods
                 result = task.on_before(
@@ -389,10 +457,10 @@ class AsyncioExecutor(BaseExecutor):
                 
                 if result and result.reject:
                     # 任务被reject，使用Hash更新
-                    self.task_info_updates[event_id] = {
-                    "status": "rejected",
+                    self.task_info_updates[status_key] = {
+                        "status": TaskStatus.REJECTED.value,
                         "consumer": consumer,
-                        "started_at": str(execution_start_time),
+                        "started_at": str(time.time()),
                         "completed_at": str(time.time()),
                         "error_msg": "Task rejected by on_before"
                     }
@@ -401,23 +469,23 @@ class AsyncioExecutor(BaseExecutor):
                     return
                 
                 # 标记任务开始执行
-                if hasattr(self.app, 'consumer_manager') and self.app.consumer_manager:
-                    self.app.consumer_manager.task_started(queue)
+                # if hasattr(self.app, 'consumer_manager') and self.app.consumer_manager:
+                #     self.app.consumer_manager.task_started(queue)
                 
                 # 更新任务真正开始执行的时间（在on_before之后）
                 execution_start_time = time.time()
                 
                 # 使用Hash更新running状态
                 # 为了让用户能看到任务正在运行，立即写入running状态
-                # running_key = f"{self.prefix}:TASK:{event_id}"
+                # running_key = f"{self.prefix}:TASK:{status_key}"
                 # 保存开始信息，但不设置status为running，避免竞态条件
-                self.task_info_updates[event_id] = {
-                    "status": "running",  # 不在这里设置status
+                self.task_info_updates[status_key] = {
+                    "status": TaskStatus.RUNNING.value,
                     "consumer": consumer,
                     "started_at": str(execution_start_time)
                 }
                 # await self.app.ep.async_redis_client.hset(running_key, mapping={
-                #     "status": "running",
+                #     "status": TaskStatus.RUNNING.value,
                 #     "consumer": consumer,
                 #     "started_at": str(execution_start_time)
                 # })
@@ -432,7 +500,12 @@ class AsyncioExecutor(BaseExecutor):
                         if current_retry > 0:
                             logger.info(f"Retry attempt {current_retry}/{max_retries} for task {event_id}")
                         
-                        task_result = task(event_id, event_data['trigger_time'], *args, **kwargs_inner)
+                        # 从kwargs中移除内部参数，避免传递给用户的任务函数
+                        clean_kwargs = {k: v for k, v in kwargs_inner.items() 
+                                      if not k.startswith('_') and not k.startswith('__')}
+                        
+                        logger.debug(f"Calling task with clean_kwargs: {clean_kwargs}")
+                        task_result = task(event_id, event_data['trigger_time'], *args, **clean_kwargs)
                         if asyncio.iscoroutine(task_result):
                             ret = await task_result
                         else:
@@ -440,14 +513,24 @@ class AsyncioExecutor(BaseExecutor):
                         result = task.on_success(
                             event_id=event_id,
                             args=args,
-                            kwargs=kwargs_inner,
+                            kwargs=clean_kwargs,
                             result=ret,
                         )
                         if asyncio.iscoroutine(result):
                             await result
                         
                         # 任务成功执行，现在可以ACK消息了
-                        await self._quick_ack(queue, event_id, group_name)
+                        # 从 event_data 中获取 offset
+                        offset = None
+                        if isinstance(event_data, dict):
+                            offset = event_data.get('offset')
+                            if offset is not None:
+                                try:
+                                    offset = int(offset)
+                                except (ValueError, TypeError):
+                                    offset = None
+                        
+                        await self._quick_ack(queue, event_id, group_name, offset)
                         
                         # 任务成功，跳出重试循环
                         break
@@ -459,7 +542,17 @@ class AsyncioExecutor(BaseExecutor):
                         exception = "System exit"
                         error_msg = "Task interrupted by shutdown"
                         # 系统退出时也需要ACK消息
-                        await self._quick_ack(queue, event_id, group_name)
+                        # 从 event_data 中获取 offset
+                        offset = None
+                        if isinstance(event_data, dict):
+                            offset = event_data.get('offset')
+                            if offset is not None:
+                                try:
+                                    offset = int(offset)
+                                except (ValueError, TypeError):
+                                    offset = None
+                        
+                        await self._quick_ack(queue, event_id, group_name, offset)
                         break
                         
                     except Exception as e:
@@ -515,8 +608,18 @@ class AsyncioExecutor(BaseExecutor):
                             error_msg = str(e)
                             logger.error(exception)
                             # 任务失败且不重试，需要ACK消息
-                            await self._quick_ack(queue, event_id, group_name)
-                            break
+                            # 从 event_data 中获取 offset
+                    offset = None
+                    if isinstance(event_data, dict):
+                        offset = event_data.get('offset')
+                        if offset is not None:
+                            try:
+                                offset = int(offset)
+                            except (ValueError, TypeError):
+                                offset = None
+                    
+                    await self._quick_ack(queue, event_id, group_name, offset)
+                    break
             
                 # 如果所有重试都失败了
                 if current_retry > max_retries and last_exception:
@@ -525,7 +628,17 @@ class AsyncioExecutor(BaseExecutor):
                     exception = filter_framework_traceback()
                     error_msg = str(last_exception)
                     # 任务最终失败，也需要ACK消息
-                    await self._quick_ack(queue, event_id, group_name)
+                    # 从 event_data 中获取 offset
+                    offset = None
+                    if isinstance(event_data, dict):
+                        offset = event_data.get('offset')
+                        if offset is not None:
+                            try:
+                                offset = int(offset)
+                            except (ValueError, TypeError):
+                                offset = None
+                    
+                    await self._quick_ack(queue, event_id, group_name, offset)
                     
                 # except块已经移到while循环内部，这里不需要了
             finally:
@@ -549,8 +662,8 @@ class AsyncioExecutor(BaseExecutor):
                 # 重要：先设置result，再设置status，确保不会出现status=success但result还没写入的情况
                 task_info = {
                     "completed_at": str(completed_at),
-                    "execution_time": str(execution_time),
-                    "duration": str(total_latency),
+                    "execution_time": execution_time,
+                    "duration": total_latency,
                     "consumer": consumer,
                     'status': status
                 }
@@ -569,19 +682,24 @@ class AsyncioExecutor(BaseExecutor):
                     
                 
                 # 更新到缓冲区
-                if event_id in self.task_info_updates:
+                if status_key in self.task_info_updates:
                     # 合并更新（保留started_at等之前的信息）
                     # 重要：确保最终状态覆盖之前的running状态
-                    self.task_info_updates[event_id].update(task_info)
+                    self.task_info_updates[status_key].update(task_info)
                 else:
-                    self.task_info_updates[event_id] = task_info
+                    self.task_info_updates[status_key] = task_info
                 
                 # 只有在 task 存在时才调用 on_end
                 if task:
+                    # 为on_end使用clean_kwargs（如果clean_kwargs未定义，则创建它）
+                    if 'clean_kwargs' not in locals():
+                        clean_kwargs = {k: v for k, v in kwargs_inner.items() 
+                                      if not k.startswith('_') and not k.startswith('__')}
+                    
                     result = task.on_end(
                         event_id=event_id,
                         args=args,
-                        kwargs=kwargs_inner,
+                        kwargs=clean_kwargs,
                         result=ret,
                         pedding_count=self.pedding_count,
                     )
@@ -664,10 +782,12 @@ class AsyncioExecutor(BaseExecutor):
                 if event:
                     event.pop("execute_time", None)
                     tasks_batch.append(event)
+                    logger.debug(f"Got event from queue: {event.get('event_id', 'unknown')}")
                 # 批量创建协程任务
                 if tasks_batch:
                     for event in tasks_batch:
                         self.batch_counter += 1
+                        logger.debug(f"Creating task for event: {event.get('event_id', 'unknown')}")
                         asyncio.create_task(self.logic(None, **event))  # semaphore 参数暂时传 None
                     
                     tasks_batch.clear()

jettask/webui/backend/config.py

@@ -0,0 +1,51 @@
+"""
+任务中心配置模块
+明确区分：
+1. 任务中心元数据库 - 存储命名空间、配置等管理数据
+2. JetTask应用数据库 - 每个命名空间配置的Redis和PostgreSQL
+"""
+import os
+from typing import Optional
+
+
+class TaskCenterDatabaseConfig:
+    """任务中心元数据库配置（用于存储命名空间等配置）"""
+    
+    def __init__(self):
+        # 元数据库配置 - 从环境变量读取
+        self.meta_db_host = os.getenv("TASK_CENTER_DB_HOST", "localhost")
+        self.meta_db_port = int(os.getenv("TASK_CENTER_DB_PORT", "5432"))
+        self.meta_db_user = os.getenv("TASK_CENTER_DB_USER", "jettask")  # 使用jettask作为默认用户
+        self.meta_db_password = os.getenv("TASK_CENTER_DB_PASSWORD", "123456")  # 使用现有密码
+        self.meta_db_name = os.getenv("TASK_CENTER_DB_NAME", "jettask")  # 使用现有数据库
+        
+        # API服务配置
+        self.api_host = os.getenv("TASK_CENTER_API_HOST", "0.0.0.0")
+        self.api_port = int(os.getenv("TASK_CENTER_API_PORT", "8001"))
+        
+        # 基础URL配置（用于生成connection_url）
+        self.base_url = os.getenv("TASK_CENTER_BASE_URL", "http://localhost:8001")
+    
+    @property
+    def meta_database_url(self) -> str:
+        """获取元数据库连接URL"""
+        return f"postgresql+asyncpg://{self.meta_db_user}:{self.meta_db_password}@{self.meta_db_host}:{self.meta_db_port}/{self.meta_db_name}"
+    
+    @property
+    def sync_meta_database_url(self) -> str:
+        """获取同步元数据库连接URL（用于初始化）"""
+        return f"postgresql://{self.meta_db_user}:{self.meta_db_password}@{self.meta_db_host}:{self.meta_db_port}/{self.meta_db_name}"
+    
+    @property
+    def pg_url(self) -> str:
+        """获取PostgreSQL连接URL（兼容旧代码）"""
+        return self.meta_database_url
+
+
+# 全局配置实例
+task_center_config = TaskCenterDatabaseConfig()
+
+
+def get_task_center_config() -> TaskCenterDatabaseConfig:
+    """获取任务中心配置"""
+    return task_center_config