node-opcua-leak-detector 2.165.0 → 2.168.0

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "node-opcua-leak-detector",
-    "version": "2.165.0",
+    "version": "2.168.0",
     "description": "pure nodejs OPCUA SDK - module leak-detector",
     "main": "index.js",
     "types": "index.d.ts",
     "scripts": {
         "lint": "eslint src/**/*.js",
         "clean": "npx rimraf -g node_modules dist *.tsbuildinfo",
-        "test": "echo no test"
+        "test": "mocha test"
     },
     "author": "Etienne Rossignon",
     "license": "MIT",
@@ -24,14 +24,14 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "fe53ac03427fcb223996446c991f7496635ba193",
+    "gitHead": "653b6d6df801ca17298308089dee32e5b12102b6",
     "files": [
         "src"
     ],
     "dependencies": {
         "chalk": "4.1.2",
         "node-opcua-assert": "2.164.0",
-        "node-opcua-object-registry": "2.165.0",
+        "node-opcua-object-registry": "2.168.0",
         "wtfnode": "^0.10.1"
     }
 }

package/src/resource_leak_detector.js

@@ -1,5 +1,4 @@
-"use strict";
-Error.stackTraceLimit = Infinity;
+Error.stackTraceLimit = 30;
 const chalk = require("chalk");
 const { assert } = require("node-opcua-assert");
 
@@ -46,23 +45,23 @@ function ResourceLeakDetector() {
  * @param info
  * @return {boolean}
  */
-ResourceLeakDetector.prototype.verify_registry_counts = function(info) {
+ResourceLeakDetector.prototype.verify_registry_counts = (info) => {
+    const self = ResourceLeakDetector.singleton;
     const errorMessages = [];
 
-    if (this.clearIntervalCallCount !== this.setIntervalCallCount) {
-        errorMessages.push(" setInterval doesn't match number of clearInterval calls : \n      " +
-            " setIntervalCallCount = " + this.setIntervalCallCount +
-            " clearIntervalCallCount = " + this.clearIntervalCallCount);
+    if (self.clearIntervalCallCount !== self.setIntervalCallCount) {
+        errorMessages.push(` setInterval doesn't match number of clearInterval calls : \n      ` +
+            ` setIntervalCallCount = ${self.setIntervalCallCount}` +
+            ` clearIntervalCallCount = ${self.clearIntervalCallCount}`);
     }
-    if ((this.clearTimeoutCallCount + this.honoredTimeoutFuncCallCount) !== this.setTimeoutCallCount) {
-        errorMessages.push(" setTimeout doesn't match number of clearTimeout or achieved timer calls : \n     " +
-            " setTimeoutCallCount = " + this.setTimeoutCallCount +
-            " clearTimeoutCallCount = " + this.clearTimeoutCallCount +
-            " honoredTimeoutFuncCallCount = " + this.honoredTimeoutFuncCallCount);
+    if ((self.clearTimeoutCallCount + self.honoredTimeoutFuncCallCount) !== self.setTimeoutCallCount) {
+        errorMessages.push(` setTimeout doesn't match number of clearTimeout or achieved timer calls : \n     ` +
+            ` setTimeoutCallCount = ${self.setTimeoutCallCount}` +
+            ` clearTimeoutCallCount = ${self.clearTimeoutCallCount}` +
+            ` honoredTimeoutFuncCallCount = ${self.honoredTimeoutFuncCallCount}`);
     }
-    if (this.setTimeoutCallPendingCount !== 0) {
-        errorMessages.push(" setTimeoutCallPendingCount is not zero: some timer are still pending " +
-            this.setTimeoutCallPendingCount);
+    if (self.setTimeoutCallPendingCount !== 0) {
+        errorMessages.push(` setTimeoutCallPendingCount is not zero: some timer are still pending ${self.setTimeoutCallPendingCount}`);
     }
 
     const monitoredResource = ObjectRegistry.registries;
@@ -72,7 +71,7 @@ ResourceLeakDetector.prototype.verify_registry_counts = function(info) {
         const res = monitoredResource[i];
         if (res.count() !== 0) {
             errorMessages.push(chalk.cyan(" some Resource have not been properly terminated: \n"));
-            errorMessages.push(" " + res.toString());
+            errorMessages.push(` ${res.toString()}`);
         }
         totalLeak += res.count();
     }
@@ -87,19 +86,19 @@ ResourceLeakDetector.prototype.verify_registry_counts = function(info) {
 
             console.log("----------------------------------------------- more info");
 
-            console.log(chalk.cyan("test filename                    : "), this.ctx ? this.ctx.test.parent.file + "  " + this.ctx.test.parent.title : "???");
-            console.log(chalk.cyan("setInterval/clearInterval leaks  : "), Object.entries(this.interval_map).length);
-            for (const [key, value] of Object.entries(this.interval_map)) {
+            console.log(chalk.cyan("test filename                    : "), self.ctx ? `${self.ctx.test.parent.file}  ${self.ctx.test.parent.title}` : "???");
+            console.log(chalk.cyan("setInterval/clearInterval leaks  : "), Object.entries(self.interval_map).length);
+            for (const [key, value] of Object.entries(self.interval_map)) {
                 if (value && !value.disposed) {
                     console.log("key =", key, "value.disposed = ", value.disposed);
-                    console.log(value.stack);//.split("\n"));
+                    console.log(value.stack);
                 }
             }
-            console.log(chalk.cyan("setTimeout/clearTimeout leaks    : "), Object.entries(this.timeout_map).length);
-            for (const [key, value] of Object.entries(this.timeout_map)) {
+            console.log(chalk.cyan("setTimeout/clearTimeout leaks    : "), Object.entries(self.timeout_map).length);
+            for (const [key, value] of Object.entries(self.timeout_map)) {
                 if (value && !value.disposed) {
                     console.log("setTimeout key =", key, "value.disposed = ", value.disposed);
-                    console.log(value.stack);//.split("\n"));
+                    console.log(value.stack);
                 }
             }
             console.log(chalk.cyan("object leaks                     : "), totalLeak);
@@ -111,21 +110,22 @@ ResourceLeakDetector.prototype.verify_registry_counts = function(info) {
 
             console.log(errorMessages.join("\n"));
 
-
-            console.log("you can get trace information if you set NODEOPCUA_REGISTRY=DEBUG and rerun")
+            console.log("you can get trace information if you set NODEOPCUA_REGISTRY=DEBUG and rerun");
             //
-            throw new Error("LEAKS !!!" + errorMessages.join("\n"));
+            throw new Error(`LEAKS !!!${errorMessages.join("\n")}`);
         }
     }
 };
 
 global.hasResourceLeakDetector = false;
-ResourceLeakDetector.prototype.start = function(info) {
+ResourceLeakDetector.prototype.start = (info) => {
 
     global.ResourceLeakDetectorStarted = true;
 
     const self = ResourceLeakDetector.singleton;
 
+
+
     if (trace) {
         console.log("[LeakDetector] 🚀 starting resourceLeakDetector");
     }
@@ -152,16 +152,21 @@ ResourceLeakDetector.prototype.start = function(info) {
 
     self.verify_registry_counts(self, info);
 
+    // Track active timer handles for cleanup in stop().
+    // This is a lightweight tracking that doesn't wrap the API (no assertions,
+    // no wrapper objects) — it just records handles so stop() can clear them.
+    self._activeTimeouts = new Set();
+
     if (monitor_intervals) {
-        global.setTimeout = function(func, delay) {
+        global.setTimeout = (func, delay, ...extra) => {
 
-            assert(arguments.length === 2, "current limitation:  setTimeout must be called with 2 arguments");
+            assert(extra.length === 0, "current limitation:  setTimeout must be called with 2 arguments");
             // detect invalid delays
             assert(delay !== undefined);
-            assert(isFinite(delay));
+            assert(Number.isFinite(delay));
             if (delay < 0) {
-                console.log("[LeakDetector] ❌ GLOBAL#setTimeout called with a too small delay = " + delay.toString());
-                throw new Error("[LeakDetector] ❌ GLOBAL#setTimeout called with a too small delay = " + delay.toString());
+                console.log(`[LeakDetector] ❌ GLOBAL#setTimeout called with a too small delay = ${delay}`);
+                throw new Error(`[LeakDetector] ❌ GLOBAL#setTimeout called with a too small delay = ${delay}`);
             }
 
             // increase number of pending timers
@@ -172,15 +177,14 @@ ResourceLeakDetector.prototype.start = function(info) {
 
             const key = self.setTimeoutCallCount;
 
-            const timeoutId = self.setTimeout_old(function() {
+            const timeoutId = self.setTimeout_old(() => {
 
                 if (!self.timeout_map[key] || self.timeout_map[key].isCleared) {
-                    // throw new Error("Invalid timeoutId, timer has already been cleared - " + key);
-                    console.log("[LeakDetector] ❌ WARNING : setTimeout:  Invalid timeoutId, timer has already been cleared - " + key);
+                    console.log(`[LeakDetector] ❌ WARNING : setTimeout:  Invalid timeoutId, timer has already been cleared - ${key}`);
                     return;
                 }
                 if (self.timeout_map[key].hasBeenHonored) {
-                    throw new Error("[LeakDetector] ❌ setTimeout:  " + key + " time out has already been honored");
+                    throw new Error(`[LeakDetector] ❌ setTimeout:  ${key} time out has already been honored`);
                 }
                 self.honoredTimeoutFuncCallCount += 1;
                 self.setTimeoutCallPendingCount -= 1;
@@ -192,7 +196,7 @@ ResourceLeakDetector.prototype.start = function(info) {
             }, delay);
 
             self.timeout_map[key] = {
-                timeoutId: timeoutId,
+                timeoutId,
                 disposed: false,
                 stack: get_stack() // stack when created
             };
@@ -209,10 +213,10 @@ ResourceLeakDetector.prototype.start = function(info) {
             return wrapper;
         };
 
-        global.clearTimeout = function(timeoutId) {
-            // workaround for a bug in 'backoff' module, which call clearTimeout with -1 ( invalid ide)
+        global.clearTimeout = (timeoutId) => {
+            // workaround for a bug in 'backoff' module, which call clearTimeout with -1 ( invalid id)
             if (timeoutId === -1) {
-                console.log("[LeakDetector] ❌ warning clearTimeout is called with illegal timeoutId === 1, this call will be ignored ( backoff module bug?)");
+                console.log("[LeakDetector] ❌ warning clearTimeout is called with illegal timeoutId === -1, this call will be ignored ( backoff module bug?)");
                 return;
             }
 
@@ -225,15 +229,15 @@ ResourceLeakDetector.prototype.start = function(info) {
             timeoutId -= 100000;
 
             if (!self.timeout_map[timeoutId]) {
-                console.log("timeoutId" + timeoutId, " has already been discarded or doesn't exist");
+                console.log(`timeoutId${timeoutId}`, " has already been discarded or doesn't exist");
                 console.log("self.timeout_map", self.timeout_map);
-                throw new Error("clearTimeout: Invalid timeoutId " + timeoutId + " this may happen if clearTimeout is called inside the setTimeout function");
+                throw new Error(`clearTimeout: Invalid timeoutId ${timeoutId} this may happen if clearTimeout is called inside the setTimeout function`);
             }
             if (self.timeout_map[timeoutId].isCleared) {
-                throw new Error("clearTimeout: Invalid timeoutId " + timeoutId + " time out has already been cleared");
+                throw new Error(`clearTimeout: Invalid timeoutId ${timeoutId} time out has already been cleared`);
             }
             if (self.timeout_map[timeoutId].hasBeenHonored) {
-                throw new Error("clearTimeout: Invalid timeoutId " + timeoutId + " time out has already been honored");
+                throw new Error(`clearTimeout: Invalid timeoutId ${timeoutId} time out has already been honored`);
             }
 
             const data = self.timeout_map[timeoutId];
@@ -250,18 +254,33 @@ ResourceLeakDetector.prototype.start = function(info) {
             // call original clearTimeout
             const retValue = self.clearTimeout_old(data.timeoutId);
 
-            //xx delete self.timeout_map[timeoutId];
             return retValue;
         };
 
+    } else {
+        // Lightweight setTimeout/clearTimeout tracking (no assertions, no wrapper IDs).
+        // We just record raw timer handles so stop() can clear leaked ones.
+        global.setTimeout = (fn, ...rest) => {
+            const handle = self.setTimeout_old(() => {
+                // Timer fired naturally — remove from tracking
+                self._activeTimeouts.delete(handle);
+                fn();
+            }, ...rest);
+            self._activeTimeouts.add(handle);
+            return handle;
+        };
+        global.clearTimeout = (handle) => {
+            self._activeTimeouts.delete(handle);
+            return self.clearTimeout_old(handle);
+        };
     }
 
-    global.setInterval = function(func, delay) {
-        assert(arguments.length === 2);
+    global.setInterval = (func, delay, ...extra) => {
+        assert(extra.length === 0);
         assert(delay !== undefined);
-        assert(isFinite(delay));
+        assert(Number.isFinite(delay));
         if (delay <= 10) {
-            throw new Error("[LeakDetector] ⏰ GLOBAL#setInterval called with a too small delay = " + delay.toString());
+            throw new Error(`[LeakDetector] ⏰ GLOBAL#setInterval called with a too small delay = ${delay}`);
         }
 
         // increase number of pending timers
@@ -275,13 +294,13 @@ ResourceLeakDetector.prototype.start = function(info) {
         try {
             stack = get_stack();
         }
-        catch (err) {
+        catch (_err) {
             /**  */
         }
         self.interval_map[key] = {
-            intervalId: intervalId,
+            intervalId,
             disposed: false,
-            stack: stack
+            stack
         };
 
         if (trace) {
@@ -300,7 +319,7 @@ ResourceLeakDetector.prototype.start = function(info) {
         return wrapper;
     };
 
-    global.clearInterval = function(intervalId) {
+    global.clearInterval = (intervalId) => {
 
         // Support both raw keys (number) and wrapper objects (from our proxy)
         const key = (intervalId && intervalId._key !== undefined) ? intervalId._key : +intervalId;
@@ -311,7 +330,7 @@ ResourceLeakDetector.prototype.start = function(info) {
         self.clearIntervalCallCount += 1;
 
         if (trace) {
-            console.log("[LeakDetector] 🔄 clearInterval " + key, get_stack());
+            console.log(`[LeakDetector] 🔄 clearInterval ${key}`, get_stack());
         }
 
         const data = self.interval_map[key];
@@ -327,11 +346,11 @@ ResourceLeakDetector.prototype.start = function(info) {
 
 };
 
-ResourceLeakDetector.prototype.check = function() {
+ResourceLeakDetector.prototype.check = () => {
     /**  */
 };
 
-ResourceLeakDetector.prototype.stop = function(info) {
+ResourceLeakDetector.prototype.stop = (info) => {
     if (!global.ResourceLeakDetectorStarted) {
         return;
     }
@@ -358,23 +377,58 @@ ResourceLeakDetector.prototype.stop = function(info) {
 
     const results = self.verify_registry_counts(info);
 
+    // Clear any remaining tracked timeouts/intervals to prevent process hang.
+    // Mocha 12+ does not call process.exit() unless --exit is set, so any
+    // ref'd timer will keep the event loop alive indefinitely.
+    for (const [, data] of Object.entries(self.interval_map)) {
+        if (data && !data.disposed) {
+            global.clearInterval(data.intervalId);
+        }
+    }
+    for (const [, data] of Object.entries(self.timeout_map)) {
+        if (data && !data.disposed) {
+            global.clearTimeout(data.timeoutId);
+        }
+    }
+    // Also clear lightweight-tracked timeout handles (monitor_intervals=false mode)
+    if (self._activeTimeouts && self._activeTimeouts.size > 0) {
+        // Count only ref'd handles (those that would prevent process exit)
+        const leakedRefHandles = [...self._activeTimeouts].filter(
+            (h) => typeof h.hasRef === "function" && h.hasRef()
+        );
+        if (leakedRefHandles.length > 0 && !info.silent) {
+            console.log(chalk.yellow(`[LeakDetector] ⚠️  ${leakedRefHandles.length} setTimeout handle(s) were not cleared!`));
+        }
+        for (const handle of self._activeTimeouts) {
+            global.clearTimeout(handle);
+        }
+        self._activeTimeouts.clear();
+    }
     self.interval_map = {};
     self.timeout_map = {};
 
-
     // call garbage collector
     if (typeof global.gc === "function") {
         global.gc(true);
     }
 
-    const doHeapdump = false;
-    if (doHeapdump) {
-        const heapdump = require('heapdump');
-        heapdump.writeSnapshot(function(err, filename) {
-            console.log('dump written to', filename);
-        });
+    // Diagnostic: dump active handles to identify what keeps the event loop alive
+    if (trace && typeof process._getActiveHandles === "function") {
+        const handles = process._getActiveHandles();
+        const refHandles = handles.filter((h) => typeof h.hasRef !== "function" || h.hasRef());
+        console.log(`[LeakDetector] 🔍 stop(): checking ${refHandles.length} active handles`);
+        for (const h of refHandles) {
+            const type = h.constructor ? h.constructor.name : typeof h;
+            console.log(`[LeakDetector]   handle: ${type}`);
+        }
     }
 
+    // Note: we no longer schedule a process.exit() timer here.
+    // The previous 2s unref'd timer was meant to handle tsx keeping
+    // ref'd stdout handles alive, but it caused premature exits when
+    // run_all_mocha_tests.js runs multiple suites in a single process.
+    // The test runner's own process.exit(failures) handles cleanup.
+
     return results;
 };
 
@@ -468,7 +522,7 @@ exports.installResourceLeakDetector = function(isGlobal, func) {
                 global.gc(true);
             }
             // give some time to relax
-            await new Promise(resolve => setTimeout(resolve, 200));
+            await new Promise((resolve) => setTimeout(resolve, 200));
             afterSnapshot = takeMemorySnapshot();
             checkForMemoryLeak(beforeSnapshot, afterSnapshot);
         });
@@ -488,7 +542,7 @@ function replacement_it(testName, f) {
                 }
                 done(err);
             });
-        }
+        };
         global_it(testName, f1);
         return;
     }
@@ -502,7 +556,7 @@ function replacement_it(testName, f) {
             throw err;
         }
         return r;
-    }
+    };
     global_it(testName, ff);
 }
 assert(typeof global_describe === "function", " expecting mocha to be defined");
@@ -526,6 +580,3 @@ exports.describeWithLeakDetector = function(message, func) {
         global.it = global_it;
     });
 };
-
-
-