@steedos-labs/plugin-workflow 3.0.62 → 3.0.63

package/main/default/manager/uuflow_manager.js

@@ -4391,8 +4391,17 @@ UUFlowManager.timeoutAutoSubmit = async function (ins_id) {
         query._id = ins_id;
     }
 
+    const startTime = Date.now();
+    console.log(`[timeout_auto_submit] Starting timeout check with query:`, JSON.stringify(query));
+
     const instances = await db.instances.find(query).toArray();
 
+    console.log(`[timeout_auto_submit] Found ${instances.length} instance(s) matching timeout criteria`);
+    if (instances.length > 0) {
+        const instanceIds = instances.map(i => i._id).join(', ');
+        console.log(`[timeout_auto_submit] Instance IDs: [${instanceIds}]`);
+    }
+
     for (const ins of instances) {
         try {
             const flow_id = ins.flow;
@@ -4401,6 +4410,7 @@ UUFlowManager.timeoutAutoSubmit = async function (ins_id) {
 
             // Only process if trace is not finished and due_date has passed
             if (trace.is_finished || !trace.due_date || new Date(trace.due_date) > new Date()) {
+                console.log(`[timeout_auto_submit] Skipping instance ${instance_id}: trace finished=${trace.is_finished}, due_date=${trace.due_date}, now=${new Date()}`);
                 continue;
             }
 
@@ -4431,8 +4441,21 @@ UUFlowManager.timeoutAutoSubmit = async function (ins_id) {
 
             // Process each unfinished approve in the trace sequentially to avoid race conditions
             const unfinishedApproves = trace.approves.filter(a => !a.is_finished);
+            console.log(`[timeout_auto_submit] Instance ${instance_id}: Processing ${unfinishedApproves.length} unfinished approve(s) | flow=${flow_id} | step=${trace.step} | type=${step_type}`);
+
+            let successCount = 0;
+            let failureCount_approves = 0;
+            let skipCount = 0;
             for (const a of unfinishedApproves) {
                 try {
+                    // Check failure count for this approve
+                    const failureCount = a.timeout_auto_submit_failures || 0;
+                    if (failureCount >= 3) {
+                        console.log(`[timeout_auto_submit] Skipping approve ${a._id} - exceeded max failures (count=${failureCount}), instance: ${instance_id}`);
+                        skipCount++;
+                        continue;
+                    }
+
                     // Create a separate approve_from_client for each approve to avoid shared mutation
                     const approve_from_client = {
                         _id: a._id,
@@ -4455,31 +4478,62 @@ UUFlowManager.timeoutAutoSubmit = async function (ins_id) {
                         continue;
                     }
 
-                    console.log(`[timeout_auto_submit] Processing approve ${a._id} for instance ${instance_id}`);
+                    console.log(`[timeout_auto_submit] Processing approve ${a._id} for instance ${instance_id} (failure_count=${failureCount})`);
                     console.log(`[timeout_auto_submit] current_user_info: ${JSON.stringify(current_user_info)}`);
 
                     const updatedInstance = await UUFlowManager.workflow_engine(
-                        approve_from_client, 
-                        current_user_info, 
-                        current_user_info._id, 
+                        approve_from_client,
+                        current_user_info,
+                        current_user_info._id,
                         true
                     );
 
                     await pushManager.send_instance_notification(
-                        "auto_submit_pending_inbox", 
-                        updatedInstance, 
-                        "", 
+                        "auto_submit_pending_inbox",
+                        updatedInstance,
+                        "",
                         current_user_info
                     );
+                    successCount++;
                 } catch (approveError) {
-                    console.error(`[timeout_auto_submit] Error processing approve ${a._id} for instance ${instance_id}: `, approveError.stack);
+                    const failureCount = (a.timeout_auto_submit_failures || 0) + 1;
+                    console.error(`[timeout_auto_submit] Error processing approve ${a._id} for instance ${instance_id} (failure_count=${failureCount}): ${approveError.message || approveError}`);
+
+                    // Update the failure count in the database
+                    try {
+                        await db.instances.updateOne(
+                            {
+                                _id: instance_id,
+                                "traces._id": trace._id
+                            },
+                            {
+                                $set: {
+                                    "traces.$[trace].approves.$[approve].timeout_auto_submit_failures": failureCount
+                                }
+                            },
+                            {
+                                arrayFilters: [
+                                    { "trace._id": trace._id },
+                                    { "approve._id": a._id }
+                                ]
+                            }
+                        );
+                        console.log(`[timeout_auto_submit] Updated failure count for approve ${a._id}: ${failureCount}`);
+                    } catch (updateError) {
+                        console.error(`[timeout_auto_submit] Failed to update failure count for approve ${a._id}: `, updateError.message || updateError);
+                    }
+                    failureCount_approves++;
                 }
             }
+            console.log(`[timeout_auto_submit] Instance ${instance_id} completed: success=${successCount} | failed=${failureCount_approves} | skipped=${skipCount}`);
         } catch (error) {
             console.error(`[timeout_auto_submit] Error processing instance ${ins._id}: `, error.stack);
         }
     }
 
+    const duration = Date.now() - startTime;
+    console.log(`[timeout_auto_submit] Completed processing ${instances.length} instance(s) in ${duration}ms`);
+
     return true;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steedos-labs/plugin-workflow",
-  "version": "3.0.62",
+  "version": "3.0.63",
   "main": "package.service.js",
   "license": "MIT",
   "files": [

package/src/instance_record_queue.js

@@ -484,9 +484,19 @@ InstanceRecordQueue.Configure = function (options) {
     }
 
     // Universal send function
-    var _querySend = function (doc) {
+    var _querySend = async function (doc) {
+        console.log(`[InstanceRecordQueue._querySend] 开始调用 sendDoc: docId=${doc._id}, insId=${doc.info.instance_id}`);
         if (InstanceRecordQueue.sendDoc) {
-            InstanceRecordQueue.sendDoc(doc);
+            try {
+                await InstanceRecordQueue.sendDoc(doc);
+                console.log(`[InstanceRecordQueue._querySend] sendDoc 执行完成: docId=${doc._id}`);
+            } catch (error) {
+                console.error(`[InstanceRecordQueue._querySend] sendDoc 执行异常: docId=${doc._id}, error=${error.message}`);
+                console.error(`[InstanceRecordQueue._querySend] 错误堆栈: ${error.stack}`);
+                throw error;
+            }
+        } else {
+            console.warn(`[InstanceRecordQueue._querySend] InstanceRecordQueue.sendDoc 未定义! docId=${doc._id}`);
         }
 
         return {
@@ -494,18 +504,20 @@ InstanceRecordQueue.Configure = function (options) {
         };
     };
 
-    self.serverSend = function (doc) {
+    self.serverSend = async function (doc) {
         doc = doc || {};
-        return _querySend(doc);
+        return await _querySend(doc);
     };
 
     var isSendingDoc = false;
 
     if (options.sendInterval !== null) {
         var sendDoc = async function (doc) {
+            console.log(`[InstanceRecordQueue.sendDoc-queue] 处理队列文档: docId=${doc._id}, insId=${doc.info.instance_id}`);
             // Reserve doc
             var now = +new Date();
             var timeoutAt = now + options.sendTimeout;
+            console.log(`[InstanceRecordQueue.sendDoc-queue] 尝试 reserve 文档: docId=${doc._id}, now=${now}, timeoutAt=${timeoutAt}`);
             var reserved = await InstanceRecordQueue.collection.update({
                 _id: doc._id,
                 sent: false, // xxx: need to make sure this is set on create
@@ -520,16 +532,20 @@ InstanceRecordQueue.Configure = function (options) {
 
             // Make sure we only handle docs reserved by this instance
             if (reserved) {
+                console.log(`[InstanceRecordQueue.sendDoc-queue] 文档 reserve 成功: docId=${doc._id}, 开始调用 serverSend`);
                 // Send
                 var result = await self.serverSend(doc);
+                console.log(`[InstanceRecordQueue.sendDoc-queue] serverSend 返回结果: docId=${doc._id}, result=${JSON.stringify(result)}`);
 
                 if (!options.keepDocs) {
                     // Pr. Default we will remove docs
+                    console.log(`[InstanceRecordQueue.sendDoc-queue] keepDocs=false, 删除文档: docId=${doc._id}`);
                     await InstanceRecordQueue.collection.remove({
                         _id: doc._id
                     });
                 } else {
                     // Update
+                    console.log(`[InstanceRecordQueue.sendDoc-queue] keepDocs=true, 设置 sent=true: docId=${doc._id}`);
                     await InstanceRecordQueue.collection.update({
                         _id: doc._id
                     }, {
@@ -543,11 +559,15 @@ InstanceRecordQueue.Configure = function (options) {
                         }
                     });
                 }
+            } else {
+                console.warn(`[InstanceRecordQueue.sendDoc-queue] 文档 reserve 失败（可能被其他实例处理）: docId=${doc._id}`);
             } // Else could not reserve
         }; // EO sendDoc
 
         sendWorker(async function () {
+            console.log(`[InstanceRecordQueue.sendWorker] 定时器触发，开始处理待发送文档...`);
             if (isSendingDoc) {
+                console.log(`[InstanceRecordQueue.sendWorker] 上一次还在处理中，跳过本次轮询`);
                 return;
             }
             // Set send fence
@@ -557,6 +577,7 @@ InstanceRecordQueue.Configure = function (options) {
 
             var now = +new Date();
 
+            console.log(`[InstanceRecordQueue.sendWorker] 查询待处理文档: batchSize=${batchSize}, now=${now}`);
             // Find docs that are not being or already sent
             var pendingDocs = await InstanceRecordQueue.collection.find({
                 $and: [
@@ -584,10 +605,14 @@ InstanceRecordQueue.Configure = function (options) {
                 },
                 limit: batchSize
             }).toArray();
+            console.log(`[InstanceRecordQueue.sendWorker] 找到待处理文档数: ${pendingDocs.length}`);
+
             for (const doc of pendingDocs) {
                 try {
+                    console.log(`[InstanceRecordQueue.sendWorker] 处理文档: docId=${doc._id}, insId=${doc.info.instance_id}`);
                     await sendDoc(doc);
                 } catch (error) {
+                    console.error(`[InstanceRecordQueue.sendWorker] 文档处理异常: docId=${doc._id}`);
                     console.error(error.stack);
                     console.log('InstanceRecordQueue: Could not send doc id: "' + doc._id + '", Error: ' + error.message);
                     await InstanceRecordQueue.collection.update({
@@ -603,6 +628,7 @@ InstanceRecordQueue.Configure = function (options) {
 
             // Remove the send fence
             isSendingDoc = false;
+            console.log(`[InstanceRecordQueue.sendWorker] 本次轮询完成，已处理 ${pendingDocs.length} 个文档`);
         }, options.sendInterval || 15000); // Default every 15th sec
     } else {
         if (InstanceRecordQueue.debug) {

package/src/timeout_auto_submit.js

@@ -54,12 +54,16 @@ TimeoutAutoSubmit.Configure = function (options = {}) {
             return;
         }
         _isProcessing = true;
+        const startTime = Date.now();
         try {
-            console.time('[timeout_auto_submit] execution');
+            console.log('[timeout_auto_submit] Starting timeout auto-submit check...');
             await UUFlowManager.timeoutAutoSubmit();
-            console.timeEnd('[timeout_auto_submit] execution');
+            const duration = Date.now() - startTime;
+            console.log(`[timeout_auto_submit] Completed in ${duration}ms`);
         } catch (error) {
-            console.error('[timeout_auto_submit] Error during scheduled execution:', error.stack || error);
+            const duration = Date.now() - startTime;
+            console.error(`[timeout_auto_submit] Fatal error after ${duration}ms: ${error.message}`);
+            console.error('[timeout_auto_submit] Stack trace:', error.stack);
         } finally {
             _isProcessing = false;
         }