@rosepetal/node-red-contrib-async-function 1.0.0 → 1.0.1

package/nodes/lib/worker-pool.js

@@ -107,6 +107,14 @@ class WorkerPool {
                         clearTimeout(readyTimeout);
                         workerState.state = WorkerState.IDLE;
                         this.workers.push(workerState);
+
+                        // Log module loading failures so users can diagnose issues
+                        if (msg.failedModules && msg.failedModules.length > 0) {
+                            for (const failed of msg.failedModules) {
+                                console.warn(`[async-function] Worker failed to load module "${failed.module}" (${failed.var}): ${failed.error}`);
+                            }
+                        }
+
                         resolve(workerState);
                     }
                 });

package/nodes/lib/worker-script.js

@@ -7,12 +7,17 @@
  */
 
 const { parentPort, workerData } = require('worker_threads');
+const { AsyncLocalStorage } = require('async_hooks');
 const { SharedMemoryManager } = require('./shared-memory-manager');
 const { AsyncMessageSerializer } = require('./message-serializer');
 
 // Track worker state
 let isTerminating = false;
 
+// AsyncLocalStorage for tracking task context across async boundaries
+// This ensures unhandled rejections can be attributed to the correct task
+const taskContext = new AsyncLocalStorage();
+
 function hrtimeDiffToMs(start) {
     if (typeof start !== 'bigint') {
         return 0;
@@ -58,6 +63,7 @@ function setCachedFunction(cacheKey, fn) {
 const loadedModules = {};
 const moduleVars = [];
 const moduleValues = [];
+const failedModules = [];  // Track modules that failed to load
 
 // Add Node-RED user directory to module search path for external modules
 if (workerData && workerData.nodeRedUserDir) {
@@ -77,6 +83,7 @@ if (workerData && workerData.libs && Array.isArray(workerData.libs)) {
                 moduleValues.push(loadedModules[lib.var]);
             } catch (err) {
                 console.error(`[async-function] Failed to load module ${lib.module}: ${err.message}`);
+                failedModules.push({ module: lib.module, var: lib.var, error: err.message });
             }
         }
     }
@@ -96,55 +103,60 @@ if (parentPort) {
 
         // Handle different message types
         if (type === 'execute') {
-            try {
-                // Restore + execute user code
-                const restoreStart = process.hrtime.bigint();
-                const restoredMsg = await serializer.restoreBuffers(msg);
-                const transferToPythonMs = hrtimeDiffToMs(restoreStart);
-
-                // Cache key includes code + module vars to handle different module configs
-                const cacheKey = code + '|' + moduleVars.join(',');
-                let userFunction = getCachedFunction(cacheKey);
-                if (!userFunction) {
-                    // Create function with msg + all module variables as parameters
-                    userFunction = new AsyncFunction('msg', ...moduleVars, code);
-                    setCachedFunction(cacheKey, userFunction);
-                }
-
-                const execStart = process.hrtime.bigint();
-                // Execute with msg and all loaded module values
-                const rawResult = await userFunction(restoredMsg, ...moduleValues);
-                const executionMs = hrtimeDiffToMs(execStart);
-
-                // Offload buffers in the result (large Buffers -> shared memory descriptors)
-                const encodeStart = process.hrtime.bigint();
-                const encodedResult = await serializer.sanitizeMessage(rawResult, null, taskId);
-                const transferToJsMs = hrtimeDiffToMs(encodeStart);
-
-                // Send result back to main thread
-                parentPort.postMessage({
-                    type: 'result',
-                    taskId,
-                    result: encodedResult,
-                    performance: {
-                        transfer_to_python_ms: transferToPythonMs,
-                        execution_ms: executionMs,
-                        transfer_to_js_ms: transferToJsMs
+            // Run task within AsyncLocalStorage context for proper error attribution
+            // This ensures unhandled rejections from fire-and-forget promises
+            // can be traced back to the correct task
+            taskContext.run({ taskId }, async () => {
+                try {
+                    // Restore + execute user code
+                    const restoreStart = process.hrtime.bigint();
+                    const restoredMsg = await serializer.restoreBuffers(msg);
+                    const transferToPythonMs = hrtimeDiffToMs(restoreStart);
+
+                    // Cache key includes code + module vars to handle different module configs
+                    const cacheKey = code + '|' + moduleVars.join(',');
+                    let userFunction = getCachedFunction(cacheKey);
+                    if (!userFunction) {
+                        // Create function with msg + all module variables as parameters
+                        userFunction = new AsyncFunction('msg', ...moduleVars, code);
+                        setCachedFunction(cacheKey, userFunction);
                     }
-                });
 
-            } catch (err) {
-                // Send error back to main thread
-                parentPort.postMessage({
-                    type: 'error',
-                    taskId,
-                    error: {
-                        message: err.message,
-                        stack: err.stack,
-                        name: err.name
-                    }
-                });
-            }
+                    const execStart = process.hrtime.bigint();
+                    // Execute with msg and all loaded module values
+                    const rawResult = await userFunction(restoredMsg, ...moduleValues);
+                    const executionMs = hrtimeDiffToMs(execStart);
+
+                    // Offload buffers in the result (large Buffers -> shared memory descriptors)
+                    const encodeStart = process.hrtime.bigint();
+                    const encodedResult = await serializer.sanitizeMessage(rawResult, null, taskId);
+                    const transferToJsMs = hrtimeDiffToMs(encodeStart);
+
+                    // Send result back to main thread
+                    parentPort.postMessage({
+                        type: 'result',
+                        taskId,
+                        result: encodedResult,
+                        performance: {
+                            transfer_to_python_ms: transferToPythonMs,
+                            execution_ms: executionMs,
+                            transfer_to_js_ms: transferToJsMs
+                        }
+                    });
+
+                } catch (err) {
+                    // Send error back to main thread
+                    parentPort.postMessage({
+                        type: 'error',
+                        taskId,
+                        error: {
+                            message: err.message,
+                            stack: err.stack,
+                            name: err.name
+                        }
+                    });
+                }
+            });
         } else if (type === 'terminate') {
             // Graceful termination requested
             isTerminating = true;
@@ -156,12 +168,13 @@ if (parentPort) {
         }
     });
 
-    // Handle errors
+    // Handle errors - use AsyncLocalStorage to get taskId for proper error attribution
     process.on('uncaughtException', (err) => {
         if (!isTerminating) {
+            const store = taskContext.getStore();
             parentPort.postMessage({
                 type: 'error',
-                taskId: null,
+                taskId: store?.taskId ?? null,
                 error: {
                     message: `Uncaught exception: ${err.message}`,
                     stack: err.stack,
@@ -173,9 +186,10 @@ if (parentPort) {
 
     process.on('unhandledRejection', (reason, _promise) => {
         if (!isTerminating) {
+            const store = taskContext.getStore();
             parentPort.postMessage({
                 type: 'error',
-                taskId: null,
+                taskId: store?.taskId ?? null,
                 error: {
                     message: `Unhandled rejection: ${reason}`,
                     stack: reason?.stack || '',
@@ -185,8 +199,9 @@ if (parentPort) {
         }
     });
 
-    // Signal ready
+    // Signal ready (include any module loading failures)
     parentPort.postMessage({
-        type: 'ready'
+        type: 'ready',
+        failedModules: failedModules.length > 0 ? failedModules : undefined
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosepetal/node-red-contrib-async-function",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A Node-RED function node that runs code in worker threads to keep your flows responsive",
   "repository": {
     "type": "git",