@inteli.city/node-red-contrib-exec-collection 2.0.2 → 2.0.3

package/README.md

@@ -595,6 +595,57 @@ Use `console.log()` to produce output.
 
 ---
 
+### Execution Modes
+
+#### Synchronous (default)
+
+Code runs in a plain function and completes immediately. No async operations are allowed.
+
+- Safe and deterministic
+- Using `await` or returning a Promise causes an explicit error
+- Use this mode for pure computation, state manipulation, and synchronous I/O
+
+#### Asynchronous (Promise-based)
+
+Select **Asynchronous (Promise-based)** from the Execution dropdown.
+
+The node waits for async work to complete before processing the next message. Your code must ensure all async work completes before execution ends.
+
+- Supports HTTP requests, database calls, file I/O, and any Promise-based API
+- Use `return <Promise>` or `await` all async calls before execution ends
+
+#### Async Usage Guidelines
+
+Always ensure async work completes before execution ends. Prefer:
+
+- `return Promise` — the node waits for the returned Promise to resolve
+- `await` all async calls — the execution boundary is the end of the async function
+
+✔ Correct — Promise returned:
+
+```js
+const axios = require('axios');
+return axios.get(url).then(r => r.data);
+```
+
+✔ Correct — await:
+
+```js
+const axios = require('axios');
+const r = await axios.get(url);
+console.log(r.data);
+```
+
+✘ Incorrect — async work is not awaited:
+
+```js
+axios.get(url).then(r => console.log(r.data));
+```
+
+**If async work is not completed before execution ends, the message may be lost or execution may fail.**
+
+---
+
 ### Worker Lifecycle
 
 - Workers start lazily on first message

package/exec.queue.html

@@ -250,7 +250,7 @@ valgrind bash $file
             field: {value:"payload", validate:RED.validators.typedInput("fieldType")},
             fieldType: {value:"msg"},
             format: {value:"javascript"},
-			template: {value:`// All msg values render as strings. Wrap in quotes for Python string literals.\n// WARNING: Nunjucks evaluates {{ }} everywhere, including inside // comments.\n\nconsole.log(\`\n{\n\t"value": "exec.queue",\n\t"purpose":"putting the ideas from the exec, template and queue nodes together"\n}\n\`)`},
+			template: {value:`// Available variables: payload, topic, and all msg properties.\n// WARNING: Do not put Nunjucks expressions inside JS comments.\n\nconsole.log(\`\n{\n\t"value": "exec.queue",\n\t"purpose":"putting the ideas from the exec, template and queue nodes together"\n}\n\`)`},
             output: {value:"str"},
 			outputEmpty: {value:false},
 			/* vimMode: {value:false}, */

package/node.queue.html

@@ -4,7 +4,55 @@
 
 Sends code to a pool of persistent Node.js workers. Each message renders the Nunjucks template into JavaScript, dispatches it to a free worker, and returns whatever `console.log()` prints as `msg.payload`.
 
-**Mental model:** you are not running a script — you are sending code to a running Node.js engine. State persists between messages on the same worker.
+**Mental model:** one message → one execution → one result. You are not running a script — you are sending code to a running Node.js engine. State persists between messages on the same worker.
+
+**Execution is mandatory:** every execution must call `console.log()` at least once. Zero-output executions are treated as errors.
+
+---
+
+## Execution Modes
+
+### Synchronous (default)
+
+Code runs in a plain function and completes immediately. No async operations are allowed.
+
+- Using `await` causes an error: *"Asynchronous operations are not allowed in synchronous mode."*
+- Returning a Promise causes the same error.
+- Execution is safe and deterministic.
+
+```js
+const value = JSON.parse("{{ payload }}");
+console.log(value + 1);
+```
+
+### Asynchronous (Promise-based)
+
+Select **Asynchronous (Promise-based)** from the Execution dropdown.
+
+The node waits for async work to complete before processing the next message. Your code must ensure all async work completes before execution ends — either by returning a Promise or by using `await`.
+
+✔ Correct — Promise returned:
+
+```js
+const axios = require('axios');
+return axios.get(url).then(r => r.data);
+```
+
+✔ Correct — await:
+
+```js
+const axios = require('axios');
+const r = await axios.get(url);
+console.log(r.data);
+```
+
+✘ Incorrect — async work is not awaited:
+
+```js
+axios.get(url).then(r => console.log(r.data));
+```
+
+**If async work is not completed before execution ends, the message may be lost or execution may fail.**
 
 ---
 
@@ -42,7 +90,7 @@ Numbers can be injected directly:
 const x = {{ payload }};   // safe when payload is a number
 ```
 
-**Warning:** Nunjucks evaluates `{{ }}` everywhere — including inside `//` and `/* */` comments. Do not put Nunjucks expressions inside comments. Comments are stripped before rendering, so they have no effect on output anyway.
+**Warning:** Nunjucks evaluates `{{ }}` everywhere — including inside `//` and `/* */` comments. Do not put Nunjucks expressions inside comments.
 
 ---
 
@@ -57,6 +105,8 @@ console.log("world");  // → one message: "world"
 
 `console.warn()` and `console.error()` go to stderr and become node warnings — they do not affect `msg.payload`.
 
+**Output is required:** if your code does not call `console.log()`, the execution fails.
+
 The bottom row controls how output is handled:
 
 **Output format** — how each segment is parsed (plain text, JSON, YAML, XML).
@@ -145,6 +195,17 @@ console.log(JSON.stringify({ platform: os.platform(), home: os.homedir() }));
             <span>Queue</span>
         </label>
         <input style="width:60px" type="number" id="node-input-queue" value="1">
+        <label for="node-input-executionMode" style="width:auto; margin-left:14px;">
+            <i class="fa fa-bolt"></i>
+            <span>Execution</span>
+        </label>
+        <select id="node-input-executionMode" style="width:240px; margin-left:4px;">
+            <option value="sync">Synchronous</option>
+            <option value="async">Asynchronous (Promise-based)</option>
+        </select>
+    </div>
+    <div id="node-nq-async-panel" style="display:none; margin: -4px 0 10px 248px; font-size:0.82em; color:#555;">
+        Your code must complete async work before execution ends. See the sidebar docs for details and examples.
     </div>
 
     <div class="form-row" style="position: relative;">
@@ -196,11 +257,13 @@ console.log(JSON.stringify({ platform: os.platform(), home: os.homedir() }));
         color: "rgb(100, 180, 140)",
         category: 'function',
         defaults: {
-            name:        { value: "" },
-            queue:       { value: 1 },
-            streamMode:  { value: "delimited" },
+            name:          { value: "" },
+            queue:         { value: 1 },
+            executionMode: { value: "sync" },
+            asyncMode:     { value: false },   // legacy — read on load for backward compat
+            streamMode:    { value: "delimited" },
             delimiter:   { value: "\\n", validate: function(v) { return typeof v === 'string' && v.length > 0; } },
-            template:    { value: "// All msg values render as strings. Wrap in quotes for JS string literals.\n// WARNING: Nunjucks evaluates {{ }} everywhere, including inside // comments.\n\nconst data = \"{{ payload }}\"\nconsole.log(data)" },
+            template:    { value: "// Available variables: payload, topic, and all msg properties.\n// WARNING: Do not put Nunjucks expressions inside JS comments.\n// In async mode, return a Promise: return axios.get(url).then(r => r.data);\n\nconsole.log(`{{ payload }}`);" },
             output:      { value: "str" },
             field:       { value: "payload", validate: RED.validators.typedInput("fieldType") },
             fieldType:   { value: "msg" },
@@ -227,6 +290,19 @@ console.log(JSON.stringify({ platform: os.platform(), home: os.homedir() }));
                 typeField: $("#node-input-fieldType")
             });
 
+            // ── execution mode ────────────────────────────────────────────────
+            // Resolve mode with backward-compat fallback for nodes saved before
+            // executionMode existed (those had asyncMode: true/false).
+            var savedMode = this.executionMode || (this.asyncMode === true ? "async" : "sync");
+            $("#node-input-executionMode").val(savedMode);
+
+            function updateExecutionModeUI() {
+                var isAsync = $("#node-input-executionMode").val() === "async";
+                $("#node-nq-async-panel").toggle(isAsync);
+            }
+            $("#node-input-executionMode").on("change", updateExecutionModeUI);
+            updateExecutionModeUI();
+
             function updateStreamUI() {
                 var mode    = $("#node-input-streamMode").val();
                 var $sel    = $("#node-input-streamMode");
@@ -333,7 +409,9 @@ console.log(JSON.stringify({ platform: os.platform(), home: os.homedir() }));
             }, 0);
         },
         oneditsave: function() {
-            this.currentLine = this.editor.getCursorPosition();
+            this.executionMode = $("#node-input-executionMode").val();
+            this.asyncMode     = (this.executionMode === "async");
+            this.currentLine   = this.editor.getCursorPosition();
             $("#node-input-template").val(this.editor.getValue());
             this.editor.destroy();
             delete this.editor;

package/node.queue.js

@@ -58,37 +58,47 @@ function buildRawContext(msg, node) {
     return ctx;
 }
 
-// ── BOOTSTRAP ─────────────────────────────────────────────────────────────────
-// Injected into each Node.js worker via node -e.
-// Reads one JSON line per execution: { "code": "...js..." }
-// Runs the code in a persistent vm context. Each console.log() immediately emits:
-//   { "t": "o", "v": "...line\n" }  — output chunk
-// After execution:
-//   { "t": "d" }                     — done (success)
-//   { "t": "e", "v": "...stack..." } — error
-// Each worker has its own isolated context — no shared state between workers.
+// ── WORKER BOOTSTRAP ──────────────────────────────────────────────────────────
+// Execution model: two explicit modes, selected per-job via d.asyncMode.
+//
+// SYNC MODE (d.asyncMode === false, default):
+//   • Code runs in a plain function(){}. No async/await allowed.
+//   • await → SyntaxError → explicit error frame.
+//   • Promise return value → detected → explicit error frame.
+//   • Completion is immediate after function returns.
+//
+// ASYNC MODE (d.asyncMode === true):
+//   • Code runs in async function(){}. MUST return a Promise or use await.
+//   • Completion = Promise resolve/reject.
+//   • Fire-and-forget (console.log after done) → error reported via __NQ_ERROR__ stderr marker.
+//
+// Both modes:
+//   • Zero console.log output → treated as failure (explicit error frame).
+//   • console.log() produces output; console.warn/error go to stderr only.
+//   • global state persists across messages on the same worker.
+//
+// Output model: all console.log calls are buffered during execution and sent
+// as a single atomic payload inside the done frame.
+//
+// Protocol (one JSON frame per stdout line):
+//   { t:'d', outputs:['line\n', ...] }  — done with all buffered output
+//   { t:'e', v:'stack...' }             — error, job failed
+//
+// Stderr fire-and-forget marker (async mode only):
+//   __NQ_ERROR__:<message>              — parent escalates to node.error()
 
 const NODE_BOOTSTRAP = `
 'use strict';
 const vm       = require('vm');
 const readline = require('readline');
 
+// console is replaced per-execution; other globals are stable across jobs.
 const ctx = vm.createContext({
     require,
     global:  {},
     process,
-    console: {
-        log:   (...a) => {
-            const v = a.map(x => typeof x === 'string' ? x : JSON.stringify(x)).join(' ');
-            process.stdout.write(JSON.stringify({ t: 'o', v: v + '\\n' }) + '\\n');
-        },
-        info:  (...a) => {
-            const v = a.map(x => typeof x === 'string' ? x : JSON.stringify(x)).join(' ');
-            process.stdout.write(JSON.stringify({ t: 'o', v: v + '\\n' }) + '\\n');
-        },
-        warn:  (...a) => process.stderr.write(a.join(' ') + '\\n'),
-        error: (...a) => process.stderr.write(a.join(' ') + '\\n'),
-    },
+    Promise,
+    console: null,
     setTimeout,
     clearTimeout,
     setInterval,
@@ -103,18 +113,96 @@ rl.on('line', (line) => {
     if (!line) return;
 
     let d;
-    try {
-        d = JSON.parse(line);
-    } catch (e) {
+    try { d = JSON.parse(line); } catch (e) {
         process.stdout.write(JSON.stringify({ t: 'e', v: 'JSON parse error: ' + e.message }) + '\\n');
         return;
     }
 
-    try {
-        vm.runInContext('(function(){"use strict";' + d.code + '\\n})()', ctx);
-        process.stdout.write(JSON.stringify({ t: 'd' }) + '\\n');
-    } catch (e) {
-        process.stdout.write(JSON.stringify({ t: 'e', v: e.stack || e.message }) + '\\n');
+    const asyncMode = d.asyncMode === true;
+
+    // Per-execution output buffer. Populated by console.log during execution.
+    // After _done is true, any further console.log calls indicate fire-and-
+    // forget code; escalated as explicit errors via the __NQ_ERROR__ marker.
+    const _outputs = [];
+    let   _done    = false;
+
+    function _fmt(args) {
+        return Array.prototype.map.call(args, function(x) {
+            return typeof x === 'string' ? x : JSON.stringify(x);
+        }).join(' ');
+    }
+
+    function _log() {
+        var v = _fmt(arguments) + '\\n';
+        if (_done) {
+            var errMsg = asyncMode
+                ? 'Async mode requires returning a Promise.\\n' +
+                  'Fire-and-forget detected: console.log() was called after execution completed.\\n' +
+                  'Fix: return axios.get(url).then(r => r.data)\\n' +
+                  'Lost value: ' + v
+                : 'Asynchronous operations are not allowed in synchronous mode.\\n' +
+                  'Switch to Asynchronous mode or remove async code.\\n' +
+                  'Lost value: ' + v;
+            process.stderr.write('__NQ_ERROR__:' + errMsg + '\\n');
+        } else {
+            _outputs.push(v);
+        }
+    }
+
+    ctx.console = { log: _log, info: _log,
+        warn:  function() { process.stderr.write(_fmt(arguments) + '\\n'); },
+        error: function() { process.stderr.write(_fmt(arguments) + '\\n'); },
+    };
+
+    if (asyncMode) {
+        // ── ASYNC MODE ────────────────────────────────────────────────────────
+        // Code runs in async function. Completion = Promise resolve/reject.
+        let _r;
+        try {
+            _r = vm.runInContext('(async function(){"use strict";\\n' + d.code + '\\n})()', ctx);
+        } catch (e) {
+            process.stdout.write(JSON.stringify({ t: 'e', v: e.stack || e.message }) + '\\n');
+            return;
+        }
+        _r.then(function() {
+            _done = true;
+            if (_outputs.length === 0) {
+                process.stdout.write(JSON.stringify({ t: 'e', v: 'Execution produced no output. Your code must call console.log() to produce output.' }) + '\\n');
+            } else {
+                process.stdout.write(JSON.stringify({ t: 'd', outputs: _outputs }) + '\\n');
+            }
+        }).catch(function(e) {
+            _done = true;
+            process.stdout.write(JSON.stringify({ t: 'e', v: e.stack || e.message }) + '\\n');
+        });
+    } else {
+        // ── SYNC MODE ─────────────────────────────────────────────────────────
+        // Code runs in a plain function. await → SyntaxError. Promise return → error.
+        let _r;
+        try {
+            _r = vm.runInContext('(function(){"use strict";\\n' + d.code + '\\n})()', ctx);
+        } catch (e) {
+            var msg = e.stack || e.message;
+            if (e.name === 'SyntaxError' && /await/.test(msg)) {
+                msg = 'Asynchronous operations are not allowed in synchronous mode.\\n' +
+                      'Switch to Asynchronous mode or remove async code.\\n\\n' + msg;
+            }
+            process.stdout.write(JSON.stringify({ t: 'e', v: msg }) + '\\n');
+            return;
+        }
+
+        // Detect Promise return (thenable) — explicit contract violation.
+        if (_r !== null && _r !== undefined && typeof _r.then === 'function') {
+            process.stdout.write(JSON.stringify({ t: 'e', v: 'Asynchronous operations are not allowed in synchronous mode.\\nSwitch to Asynchronous mode or remove async code.\\n\\n(Your code returned a Promise — this is not allowed in synchronous mode.)' }) + '\\n');
+            return;
+        }
+
+        _done = true;
+        if (_outputs.length === 0) {
+            process.stdout.write(JSON.stringify({ t: 'e', v: 'Execution produced no output. Your code must call console.log() to produce output.' }) + '\\n');
+        } else {
+            process.stdout.write(JSON.stringify({ t: 'd', outputs: _outputs }) + '\\n');
+        }
     }
 });
 `;
@@ -186,6 +274,8 @@ module.exports = function(RED) {
         this.fieldType    = n.fieldType || 'msg';
         this.queue        = Math.max(1, Number(n.queue) || 1);
         this.streamMode   = n.streamMode || 'delimited';
+        // executionMode is canonical; asyncMode is the legacy boolean (backward compat).
+        this.asyncMode    = (n.executionMode === "async") || (n.asyncMode === true);
 
         // Interpret escape sequences in the stored delimiter string: \n → newline, \t → tab, \r → CR
         const delimRaw  = (n.delimiter !== undefined && n.delimiter !== '') ? n.delimiter : '\\n';
@@ -199,6 +289,16 @@ module.exports = function(RED) {
         let pendingQueue = [];
         let closing      = false;
 
+        // ── observability counters (REQ 6) ────────────────────────────────────
+        // Invariant: received = sent + errored + killed + in-flight (always)
+        // sent tracks item.send() calls — the only valid flow-level output signal.
+        const counters = { received: 0, sent: 0, completed: 0, errored: 0, killed: 0 };
+
+        function logCounters(event) {
+            const inflight = counters.received - counters.completed - counters.errored - counters.killed;
+            node.log(`[node.queue] ${event} | recv=${counters.received} sent=${counters.sent} done=${counters.completed} err=${counters.errored} kill=${counters.killed} inflight=${inflight}`);
+        }
+
         // ── status state ──────────────────────────────────────────────────────
         let currentState     = { waiting: 0, executing: 0, workers: 0 };
         let lastEmittedState = null;
@@ -223,14 +323,16 @@ module.exports = function(RED) {
             if (node.fieldType === 'msg') {
                 const outMsg = Object.assign({}, item.msg);
                 RED.util.setMessageProperty(outMsg, node.field, result.value);
+                counters.sent++;
                 item.send(outMsg);
             } else {
                 const context = RED.util.parseContextStore(node.field);
                 const target  = node.context()[node.fieldType];
                 const outMsg  = Object.assign({}, item.msg);
                 target.set(context.key, result.value, context.store, (err) => {
-                    if (err) node.error(err);
-                    else item.send(outMsg);
+                    if (err) { node.error(err); return; }
+                    counters.sent++;
+                    item.send(outMsg);
                 });
             }
         }
@@ -250,20 +352,34 @@ module.exports = function(RED) {
             }
         }
 
-        // ── stream frame handler ──────────────────────────────────────────────
+        // ── frame handler ─────────────────────────────────────────────────────
+        //
+        // Protocol frames (one JSON object per stdout line):
+        //   { t:'d', outputs:['line\n', ...] }  — job done, all output included
+        //   { t:'e', v:'stack...' }             — job failed with error
+        //
+        // Outputs are buffered inside the worker and arrive atomically in the
+        // done frame — they are guaranteed to precede it in the stdout stream.
+        // All sends therefore happen before done(), satisfying the flow-level
+        // delivery guarantee (REQ 1, 4).
+        //
+        // REQ 7: any frame arriving when currentItem is null is a protocol
+        // violation. It means either a worker bug or fire-and-forget code that
+        // bypassed the buffer (impossible with the current bootstrap). Either
+        // way it must be reported as an explicit error, never silently ignored.
 
-        // Handles one JSON line from the worker's stdout.
-        // Frames: { t:'o', v:chunk } | { t:'d' } | { t:'e', v:stack }
         function handleStreamFrame(worker, line) {
             let frame;
             try {
                 frame = JSON.parse(line);
             } catch (e) {
-                node.error(`JSON parse error from Node.js worker: ${e.message}\nRaw: ${line}`);
+                node.error(`[node.queue] JSON parse error from worker: ${e.message}\nRaw: ${line}`);
                 if (worker.currentItem) {
                     const item = worker.currentItem;
                     worker.currentItem = null;
                     worker.busy = false;
+                    counters.errored++;
+                    logCounters('parse-error');
                     item.done(e);
                     resetIdleTimer();
                     processNext();
@@ -273,22 +389,25 @@ module.exports = function(RED) {
             }
 
             const item = worker.currentItem;
-            if (!item) return; // killed — ignore late frames silently
 
-            if (frame.t === 'o') {
-                handleOutputChunk(item, frame.v);
+            // REQ 7 — frame with no active job is always an error.
+            if (!item) {
+                node.error(`[node.queue] Frame (t:${frame.t}) received with no active job — possible worker bug or protocol error. Raw: ${line}`);
                 return;
             }
 
-            // 'd' or 'e' — job is finished
-            worker.currentItem = null;
-            worker.busy = false;
+            // ── done ──────────────────────────────────────────────────────────
+            if (frame.t === 'd') {
+                worker.currentItem = null;
+                worker.busy = false;
+
+                // Process all buffered output then call done.
+                // Outputs are emitted via item.send() before item.done() so the
+                // downstream node receives the message before the job closes.
+                for (const chunk of (frame.outputs || [])) {
+                    handleOutputChunk(item, chunk);
+                }
 
-            if (frame.t === 'e') {
-                node.error(`Node.js worker error:\n${frame.v}`);
-                item.done(new Error(frame.v));
-            } else {
-                // Flush buffered content before signalling done
                 if (node.streamMode === 'delimited' && item.segmentBuffer) {
                     emitSegment(item, item.segmentBuffer);
                     item.segmentBuffer = '';
@@ -297,12 +416,32 @@ module.exports = function(RED) {
                     emitSegment(item, item.rawBuffer);
                     item.rawBuffer = '';
                 }
+
+                counters.completed++;
+                logCounters('done');
                 item.done();
+                resetIdleTimer();
+                processNext();
+                computeAndStoreState();
+                return;
             }
 
-            resetIdleTimer();
-            processNext();
-            computeAndStoreState();
+            // ── error ─────────────────────────────────────────────────────────
+            if (frame.t === 'e') {
+                worker.currentItem = null;
+                worker.busy = false;
+                counters.errored++;
+                logCounters('error');
+                node.error(`[node.queue] Worker error:\n${frame.v}`);
+                item.done(new Error(frame.v));
+                resetIdleTimer();
+                processNext();
+                computeAndStoreState();
+                return;
+            }
+
+            // Unknown frame type — warn but keep the job alive.
+            node.warn(`[node.queue] Unknown frame type "${frame.t}" from worker — ignored`);
         }
 
         // ── worker management ─────────────────────────────────────────────────
@@ -325,7 +464,17 @@ module.exports = function(RED) {
 
             proc.stderr.on('data', (data) => {
                 const text = Buffer.isBuffer(data) ? data.toString() : String(data);
-                if (text && text.trim().length > 0) node.warn(text.trim());
+                if (!text || !text.trim()) return;
+                // Lines prefixed with __NQ_ERROR__: are contract violations escalated to node.error().
+                for (const line of text.split('\n')) {
+                    const t = line.trim();
+                    if (!t) continue;
+                    if (t.startsWith('__NQ_ERROR__:')) {
+                        node.error(t.slice('__NQ_ERROR__:'.length));
+                    } else {
+                        node.warn(t);
+                    }
+                }
             });
 
             proc.on('error', (err) => {
@@ -334,10 +483,15 @@ module.exports = function(RED) {
                 node.error(`Node.js worker error: ${errMsg}`);
                 workers = workers.filter(w => w !== worker);
                 if (worker.currentItem) {
-                    worker.currentItem.done(new Error(errMsg));
+                    const item = worker.currentItem;
                     worker.currentItem = null;
+                    worker.busy = false;
+                    counters.errored++;
+                    logCounters('worker-error');
+                    item.done(new Error(errMsg));
+                } else {
+                    worker.busy = false;
                 }
-                worker.busy = false;
                 processNext();
                 computeAndStoreState();
             });
@@ -347,10 +501,15 @@ module.exports = function(RED) {
                 workers = workers.filter(w => w !== worker);
                 if (worker.currentItem) {
                     node.warn(`Node.js worker exited (code ${code}) — failing current job`);
-                    worker.currentItem.done(new Error(`Node.js worker exited with code ${code}`));
+                    const item = worker.currentItem;
                     worker.currentItem = null;
+                    worker.busy = false;
+                    counters.errored++;
+                    logCounters('worker-close');
+                    item.done(new Error(`Node.js worker exited with code ${code}`));
+                } else {
+                    worker.busy = false;
                 }
-                worker.busy = false;
                 processNext();
                 computeAndStoreState();
             });
@@ -401,11 +560,13 @@ module.exports = function(RED) {
             worker.currentItem = item;
 
             try {
-                worker.proc.stdin.write(JSON.stringify({ code: item.rendered }) + '\n');
+                worker.proc.stdin.write(JSON.stringify({ code: item.rendered, asyncMode: node.asyncMode }) + '\n');
             } catch (e) {
                 node.error(`Failed to write to Node.js worker stdin: ${e.message}`);
                 worker.busy        = false;
                 worker.currentItem = null;
+                counters.errored++;
+                logCounters('stdin-error');
                 item.done(e);
             }
 
@@ -468,6 +629,7 @@ module.exports = function(RED) {
         function computeAndStoreState() {
             currentState = computeState();
             node.currentState = currentState;
+            node.counters     = counters;
             scheduleStatusEmit();
         }
 
@@ -477,13 +639,16 @@ module.exports = function(RED) {
         function killAll() {
             for (const w of workers) {
                 if (w.currentItem) {
-                    w.currentItem.done();
+                    const item = w.currentItem;
                     w.currentItem = null;
+                    counters.killed++;
+                    item.done();
                 }
                 try { w.proc.kill('SIGTERM'); } catch (_) {}
             }
             workers = [];
             for (const item of pendingQueue) {
+                counters.killed++;
                 item.done();
             }
             pendingQueue = [];
@@ -503,21 +668,23 @@ module.exports = function(RED) {
                 return;
             }
 
+            counters.received++;
+
             const template = selectTemplate(msg, node);
             const context  = buildRawContext(msg, node);
 
             let rendered;
             try {
                 const env = new nunjucks.Environment(null, { autoescape: false });
-                const stripped = template
-                    .replace(/\/\/.*$/gm, '')
-                    .replace(/\/\*[\s\S]*?\*\//g, '');
-                rendered = env.renderString(stripped, context);
+                rendered = env.renderString(template, context);
             } catch (e) {
                 node.error(
                     'Template render error: ' + e.message +
-                    '\nTip: Do not use {{ }} inside comments. Nunjucks parses the entire template.'
+                    '\nTip: Do not put Nunjucks expressions inside JS comments.',
+                    msg
                 );
+                counters.errored++;
+                logCounters('template-error');
                 done(e);
                 return;
             }
@@ -560,7 +727,8 @@ module.exports = function(RED) {
         if (n) {
             res.json({
                 executing: n.currentState ? n.currentState.executing : 0,
-                workers:   n.currentState ? n.currentState.workers   : 0
+                workers:   n.currentState ? n.currentState.workers   : 0,
+                counters:  n.counters     || { received: 0, sent: 0, completed: 0, errored: 0, killed: 0 }
             });
         } else {
             res.sendStatus(404);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name" : "@inteli.city/node-red-contrib-exec-collection",
-	"version": "2.0.2",
+	"version": "2.0.3",
 	"dependencies": {
 		"fs": "*",
         "tmp-promise": "*",