@nocobase/plugin-async-task-manager 2.1.2 → 2.1.4

package/dist/externalVersion.js

@@ -8,19 +8,19 @@
  */
 
 module.exports = {
-  "@nocobase/client": "2.1.2",
+  "@nocobase/client": "2.1.4",
   "react": "18.2.0",
-  "@nocobase/utils": "2.1.2",
-  "@nocobase/flow-engine": "2.1.2",
-  "@nocobase/client-v2": "2.1.2",
+  "@nocobase/utils": "2.1.4",
+  "@nocobase/flow-engine": "2.1.4",
+  "@nocobase/client-v2": "2.1.4",
   "lodash": "4.18.1",
-  "@nocobase/server": "2.1.2",
-  "@nocobase/logger": "2.1.2",
-  "@nocobase/database": "2.1.2",
+  "@nocobase/server": "2.1.4",
+  "@nocobase/logger": "2.1.4",
+  "@nocobase/database": "2.1.4",
   "antd": "5.24.2",
   "react-i18next": "11.18.6",
   "dayjs": "1.11.13",
   "@ant-design/icons": "5.6.1",
   "ahooks": "3.7.8",
-  "@nocobase/actions": "2.1.2"
+  "@nocobase/actions": "2.1.4"
 };

package/dist/server/base-task-manager.d.ts

@@ -15,6 +15,7 @@ import { ConcurrencyMode, ConcurrencyMonitor } from './interfaces/concurrency-mo
 export declare class BaseTaskManager implements AsyncTasksManager {
     private taskTypes;
     private tasks;
+    private taskReqIds;
     private readonly cleanupDelay;
     private cleanupTimer;
     private logger;
@@ -35,13 +36,14 @@ export declare class BaseTaskManager implements AsyncTasksManager {
     setLogger(logger: Logger): void;
     setApp(app: Application): void;
     private enqueueTask;
+    private getTaskLogger;
     cancelTask(taskId: TaskId, externally?: boolean): Promise<void>;
     createTask(data: TaskModel, { useQueue, ...options }?: CreateTaskOptions): Promise<ITask>;
     getTask(taskId: TaskId): ITask | undefined;
     getTaskStatus(taskId: TaskId): Promise<TaskStatus>;
     registerTaskType(taskType: TaskConstructor): void;
     private prepareTask;
-    runTask(task: ITask): Promise<void>;
+    runTask(task: ITask, reqId?: string): Promise<void>;
 }
 export declare class ConcurrencyMonitorDelegate implements ConcurrencyMonitor {
     private mode;

package/dist/server/base-task-manager.js

@@ -52,6 +52,7 @@ const PROCESS_CONCURRENCY_MONITOR = new import_base_concurrency_monitor.BaseConc
 class BaseTaskManager {
   taskTypes = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
+  taskReqIds = /* @__PURE__ */ new Map();
   // Clean up completed tasks after 30 minutes by default
   cleanupDelay = 30 * 60 * 1e3;
   cleanupTimer;
@@ -66,21 +67,21 @@ class BaseTaskManager {
     this.concurrencyMonitor.concurrency = concurrency;
   }
   idle = () => this.app.serving(WORKER_JOB_ASYNC_TASK_PROCESS) && this.concurrencyMonitor.idle();
-  onQueueTask = async ({ id }, { queueOptions }) => {
+  onQueueTask = async ({ id, reqId }, { queueOptions }) => {
     const task = await this.prepareTask(id);
     if (!this.concurrencyMonitor.increase(task.record.id)) {
-      this.enqueueTask(task, queueOptions);
+      this.enqueueTask(task, queueOptions, reqId);
       return;
     }
     try {
-      await this.runTask(task);
+      await this.runTask(task, reqId);
     } finally {
       this.concurrencyMonitor.decrease(task.record.id);
     }
   };
-  onTaskProgress = (item) => {
+  onTaskProgress = (item, logger) => {
     const userId = item.createdById;
-    this.logger.trace(`Task ${item.id} of user(${userId}) progress: ${item.progressCurrent} / ${item.progressTotal}`);
+    logger.trace(`Task ${item.id} of user(${userId}) progress: ${item.progressCurrent} / ${item.progressTotal}`);
     if (userId) {
       const throttledEmit = this.getThrottledProgressEmitter(item.id, userId);
       throttledEmit(item);
@@ -100,6 +101,12 @@ class BaseTaskManager {
   };
   onTaskStatusChanged = (task) => {
     if (!task.changed("status")) return;
+    if (task.doneAt) {
+      this.progressThrottles.delete(task.id);
+      this.tasks.delete(task.id);
+      this.taskReqIds.delete(task.id);
+      this.concurrencyMonitor.decrease(task.id);
+    }
     const userId = task.createdById;
     if (!userId) return;
     this.app.emit("ws:sendToUser", {
@@ -119,17 +126,13 @@ class BaseTaskManager {
         this.progressThrottles.delete(task.id);
       }
     }
-    if (task.doneAt) {
-      this.progressThrottles.delete(task.id);
-      this.tasks.delete(task.id);
-      this.concurrencyMonitor.decrease(task.id);
-    }
     if (task.status === import_constants.TASK_STATUS.SUCCEEDED) {
       this.app.emit("workflow:dispatch");
     }
   };
   onTaskAfterDelete = (task) => {
     this.tasks.delete(task.id);
+    this.taskReqIds.delete(task.id);
     this.progressThrottles.delete(task.id);
     this.concurrencyMonitor.decrease(task.id);
     const userId = task.createdById;
@@ -170,6 +173,7 @@ class BaseTaskManager {
       if (tasksToCleanup.length) {
         for (const task of tasksToCleanup) {
           this.tasks.delete(task.id);
+          this.taskReqIds.delete(task.id);
           this.progressThrottles.delete(task.id);
           this.concurrencyMonitor.decrease(task.id);
         }
@@ -238,9 +242,12 @@ class BaseTaskManager {
     this.app.db.on("asyncTasks.afterUpdate", this.onTaskStatusChanged);
     this.app.db.on("asyncTasks.afterDestroy", this.onTaskAfterDelete);
   }
-  enqueueTask(task, queueOptions) {
+  enqueueTask(task, queueOptions, reqId = this.taskReqIds.get(task.record.id)) {
     const plugin = this.app.pm.get(import_plugin.default);
-    this.app.eventQueue.publish(`${plugin.name}.task`, { id: task.record.id }, queueOptions);
+    this.app.eventQueue.publish(`${plugin.name}.task`, { id: task.record.id, reqId }, queueOptions);
+  }
+  getTaskLogger(reqId) {
+    return reqId ? this.logger.child({ reqId }) : this.logger;
   }
   async cancelTask(taskId, externally = false) {
     const task = this.tasks.get(taskId);
@@ -271,9 +278,12 @@ class BaseTaskManager {
     }
   }
   async createTask(data, { useQueue, ...options } = {}) {
+    var _a;
+    const reqId = (_a = options.context) == null ? void 0 : _a.reqId;
+    const logger = this.getTaskLogger(reqId);
     const taskType = this.taskTypes.get(data.type);
     if (!taskType) {
-      this.logger.error(`Task type not found: ${data.type}, params: ${JSON.stringify(data.params)}`);
+      logger.error(`Task type not found: ${data.type}, params: ${JSON.stringify(data.params)}`);
       throw new Error(`Task type ${data.type} not found`);
     }
     const values = taskType.defaults({
@@ -283,14 +293,17 @@ class BaseTaskManager {
     });
     const DBTaskModel = this.app.db.getModel("asyncTasks");
     const record = await DBTaskModel.create(values, options);
-    this.logger.debug(`Creating task of type: ${data.type}`);
-    this.logger.debug(`Task data: ${JSON.stringify(data)}`);
+    logger.debug(`Creating task of type: ${data.type}`);
+    logger.debug(`Task data: ${JSON.stringify(data)}`);
     const task = new taskType(record);
-    this.logger.info(`New task of type: ${data.type} created as ${record.id}`);
+    if (reqId && !useQueue) {
+      this.taskReqIds.set(record.id, reqId);
+    }
+    logger.info(`New task of type: ${data.type} created as ${record.id}`);
     if (useQueue) {
-      this.logger.debug(`New task ${record.id} will be sent to queue for processing`);
+      logger.debug(`New task ${record.id} will be sent to queue for processing`);
       const queueOptions = typeof useQueue === "object" ? useQueue : {};
-      this.enqueueTask(task, queueOptions);
+      this.enqueueTask(task, queueOptions, reqId);
     }
     return task;
   }
@@ -329,19 +342,21 @@ class BaseTaskManager {
     const task = new taskType(record);
     return task;
   }
-  async runTask(task) {
+  async runTask(task, reqId = this.taskReqIds.get(task.record.id)) {
     if (task.record.status === import_constants.TASK_STATUS.PENDING) {
-      task.setLogger(this.logger);
+      const logger = this.getTaskLogger(reqId);
+      task.setLogger(logger);
       task.setApp(this.app);
-      task.onProgress = this.onTaskProgress;
+      task.onProgress = (record) => this.onTaskProgress(record, logger);
       this.tasks.set(task.record.id, task);
       try {
-        this.logger.debug(`Starting execution of task ${task.record.id} from queue`);
+        logger.debug(`Starting execution of task ${task.record.id} from queue`);
         await task.run();
       } catch (error) {
-        this.logger.error(`Error executing task ${task.record.id} from queue: ${error.message}`);
+        logger.error(`Error executing task ${task.record.id} from queue: ${error.message}`);
       } finally {
         this.tasks.delete(task.record.id);
+        this.taskReqIds.delete(task.record.id);
       }
     }
   }

package/dist/server/interfaces/async-task-manager.d.ts

@@ -13,7 +13,9 @@ import { TaskId, TaskStatus } from '../../common/types';
 import { Transactionable } from '@nocobase/database';
 export interface CreateTaskOptions extends Transactionable {
     useQueue?: boolean | QueueMessageOptions;
-    context?: any;
+    context?: object & {
+        reqId?: string;
+    };
 }
 export interface AsyncTasksManager {
     concurrency: number;
@@ -24,7 +26,7 @@ export interface AsyncTasksManager {
     cancelTask(taskId: TaskId): Promise<void>;
     getTaskStatus(taskId: TaskId): Promise<TaskStatus>;
     getTask(taskId: TaskId): ITask | undefined;
-    runTask(task: ITask): Promise<void>;
+    runTask(task: ITask, reqId?: string): Promise<void>;
 }
 export declare class CancelError extends Error {
     constructor(message?: string);

package/package.json

@@ -6,7 +6,7 @@
   "description": "Manage and monitor asynchronous tasks such as data import/export. Support task progress tracking and notification.",
   "description.ru-RU": "Управление асинхронными задачами и мониторинг (например, импорт/экспорт данных). Поддержка отслеживания прогресса и уведомлений о задачах.",
   "description.zh-CN": "管理和监控数据导入导出等异步任务。支持任务进度跟踪和通知。",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "main": "dist/server/index.js",
   "peerDependencies": {
     "@nocobase/client": "2.x",
@@ -19,5 +19,5 @@
     "p-queue": "^6.6.2"
   },
   "license": "Apache-2.0",
-  "gitHead": "e1b28561425c5c34ff3bc6ae1f81c66b72f02872"
+  "gitHead": "73c01b1e842afdaafdffd6fa4bb090c1da9b0816"
 }