node-opcua-leak-detector 2.157.0 → 2.164.0

package/index.js

@@ -1,4 +1,10 @@
 "use strict";
+
+const { describeWithLeakDetector } = require("./src/resource_leak_detector");
+const { takeMemorySnapshot, checkForMemoryLeak } = require("./src/mem_leak_detector");
+
 module.exports = {
-    describeWithLeakDetector: require("./src/resource_leak_detector").describeWithLeakDetector
+    describeWithLeakDetector,
+    takeMemorySnapshot,
+    checkForMemoryLeak
 };

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "node-opcua-leak-detector",
-    "version": "2.157.0",
+    "version": "2.164.0",
     "description": "pure nodejs OPCUA SDK - module leak-detector",
     "main": "index.js",
-    "type": "index.d.ts",
+    "types": "index.d.ts",
     "scripts": {
         "lint": "eslint src/**/*.js",
         "clean": "npx rimraf -g node_modules dist *.tsbuildinfo",
@@ -24,13 +24,14 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "e0a948ac5379ae8d9cc8200a1b4a31515a35be37",
+    "gitHead": "eb76d34b885c7584785d8eff69ada66f95b55c2e",
     "files": [
         "src"
     ],
     "dependencies": {
         "chalk": "4.1.2",
-        "node-opcua-assert": "2.157.0",
-        "node-opcua-object-registry": "2.157.0"
+        "node-opcua-assert": "2.164.0",
+        "node-opcua-object-registry": "2.164.0",
+        "wtfnode": "^0.10.1"
     }
 }

package/src/mem_leak_detector.js

@@ -0,0 +1,76 @@
+// memoryLeakDetector.js
+let wtf;
+
+
+if (process.env.MEM_LEAK_DETECTION_WTF_ENABLED) {
+  console.log("[LeakDetector] ⚠️ WTFNODE enabled");
+  wtf = require('wtfnode');
+  wtf.init();
+} else {
+  console.log("[LeakDetector] ℹ️  WTFNODE disabled. Use MEM_LEAK_DETECTION_WTF_ENABLED=true to enable it.");
+}
+
+
+let noGCexposed = undefined;
+
+/**
+ * Forces garbage collection if available.
+ */
+function forceGC() {
+  if (global.gc) {
+    global.gc();
+    noGCexposed = false;
+  } else {
+    if (noGCexposed == undefined) {
+      console.warn('[LeakDetector] ⚠️ Garbage collection not exposed. Run Node.js with --expose-gc flag for more accurate results.');
+    }
+    noGCexposed = true;
+  }
+}
+
+/**
+ * Takes a memory snapshot.
+ * @returns {number} Heap used in bytes.
+ */
+function takeMemorySnapshot() {
+  if (noGCexposed) {
+    return;
+  }
+  forceGC();
+  return process.memoryUsage().heapUsed;
+}
+
+/**
+ * Checks for memory leaks between before and after snapshots.
+ * @param {number} before - Heap used before test.
+ * @param {number} after - Heap used after test.
+ * @param {number} [threshold=10] - Threshold in MB to consider as a leak.
+ * @returns {Object} - Result with before/after memory and leak status.
+ */
+function checkForMemoryLeak(before, after, threshold = 2) {
+
+  if (noGCexposed) {
+    return;
+  }
+  const heapUsedBefore = before / 1024 / 1024; // MB
+  const heapUsedAfter = after / 1024 / 1024; // MB
+  const delta = heapUsedAfter - heapUsedBefore;
+  const isLeak = delta > threshold;
+
+  if (isLeak) {
+    console.warn(
+      `[LeakDetector] ⚠️ Potential memory leak detected in test: ${delta.toFixed(2)} MB increase (threshold: ${threshold} MB , total : ${heapUsedAfter.toFixed(2)} MB)`
+    );
+  } else {
+    console.log(
+      `[LeakDetector] ✅ No significant memory leak detected: ${delta.toFixed(2)} MB increase total : ${heapUsedAfter.toFixed(2)} MB`
+    );
+  }
+
+
+  wtf?.dump({ fullStacks: true }); // Show open handles, listeners, etc.
+
+  return { before: heapUsedBefore, after: heapUsedAfter, delta, isLeak };
+}
+
+module.exports = { takeMemorySnapshot, checkForMemoryLeak };

package/src/resource_leak_detector.js

@@ -1,12 +1,22 @@
 "use strict";
 Error.stackTraceLimit = Infinity;
-
 const chalk = require("chalk");
 const { assert } = require("node-opcua-assert");
 
 const { ObjectRegistry } = require("node-opcua-object-registry");
+const { takeMemorySnapshot, checkForMemoryLeak } = require("./mem_leak_detector");
+
 const trace = false;
 
+const memLeakDetectionDisabled = process.env.MEM_LEAK_DETECTION_DISABLED === "true";
+if (memLeakDetectionDisabled) {
+    console.log("[LeakDetector] ⚠️  Memory leak detection is disabled");
+} else {
+    // if MEM_LEAK_DETECTION_DISABLED is undefined, inform the user that it exists
+    if (process.env.MEM_LEAK_DETECTION_DISABLED === undefined) {
+        console.log("[LeakDetector] ℹ️  Memory leak detection is enabled. Set MEM_LEAK_DETECTION_DISABLED=true to disable it.");
+    }
+}
 
 function get_stack() {
     const stack = (new Error("Stack Trace recording")).stack.split("\n");
@@ -117,7 +127,7 @@ ResourceLeakDetector.prototype.start = function(info) {
     const self = ResourceLeakDetector.singleton;
 
     if (trace) {
-        console.log(" starting resourceLeakDetector");
+        console.log("[LeakDetector] 🚀 starting resourceLeakDetector");
     }
     assert(!self.setInterval_old, "resourceLeakDetector.stop hasn't been called !");
     assert(!self.clearInterval_old, "resourceLeakDetector.stop hasn't been called !");
@@ -150,8 +160,8 @@ ResourceLeakDetector.prototype.start = function(info) {
             assert(delay !== undefined);
             assert(isFinite(delay));
             if (delay < 0) {
-                console.log("GLOBAL#setTimeout called with a too small delay = " + delay.toString());
-                throw new Error("GLOBAL#setTimeout called with a too small delay = " + delay.toString());
+                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());
             }
 
             // increase number of pending timers
@@ -166,11 +176,11 @@ ResourceLeakDetector.prototype.start = function(info) {
 
                 if (!self.timeout_map[key] || self.timeout_map[key].isCleared) {
                     // throw new Error("Invalid timeoutId, timer has already been cleared - " + key);
-                    console.log("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("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;
@@ -186,18 +196,31 @@ ResourceLeakDetector.prototype.start = function(info) {
                 disposed: false,
                 stack: get_stack() // stack when created
             };
-            return key + 100000;
+
+            // Return a wrapper that acts as the key (for clearTimeout)
+            // but also exposes ref/unref/hasRef from the real Timeout
+            const wrapper = {
+                [Symbol.toPrimitive]() { return key + 100000; },
+                ref() { timeoutId.ref(); return wrapper; },
+                unref() { timeoutId.unref(); return wrapper; },
+                hasRef() { return timeoutId.hasRef(); },
+                _key: key + 100000
+            };
+            return wrapper;
         };
 
         global.clearTimeout = function(timeoutId) {
             // workaround for a bug in 'backoff' module, which call clearTimeout with -1 ( invalid ide)
             if (timeoutId === -1) {
-                console.log("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;
             }
 
+            // Support both raw keys (number) and wrapper objects (from our proxy)
+            timeoutId = (timeoutId && timeoutId._key !== undefined) ? timeoutId._key : +timeoutId;
+
             if (timeoutId >= 0 && timeoutId < 100000) {
-                throw new Error("clearTimeout has been called instead of clearInterval");
+                throw new Error("[LeakDetector] ❌ clearTimeout has been called instead of clearInterval");
             }
             timeoutId -= 100000;
 
@@ -238,7 +261,7 @@ ResourceLeakDetector.prototype.start = function(info) {
         assert(delay !== undefined);
         assert(isFinite(delay));
         if (delay <= 10) {
-            throw new Error("GLOBAL#setInterval called with a too small delay = " + delay.toString());
+            throw new Error("[LeakDetector] ⏰ GLOBAL#setInterval called with a too small delay = " + delay.toString());
         }
 
         // increase number of pending timers
@@ -265,20 +288,31 @@ ResourceLeakDetector.prototype.start = function(info) {
             console.log("setInterval \n", get_stack(), "\n");
         }
 
-        return key;
+        // Return a wrapper that acts as the key (for clearInterval)
+        // but also exposes ref/unref/hasRef from the real Timeout
+        const wrapper = {
+            [Symbol.toPrimitive]() { return key; },
+            ref() { intervalId.ref(); return wrapper; },
+            unref() { intervalId.unref(); return wrapper; },
+            hasRef() { return intervalId.hasRef(); },
+            _key: key
+        };
+        return wrapper;
     };
 
     global.clearInterval = function(intervalId) {
 
-        if (intervalId >= 100000) {
-            throw new Error("clearInterval has been called instead of clearTimeout");
+        // Support both raw keys (number) and wrapper objects (from our proxy)
+        const key = (intervalId && intervalId._key !== undefined) ? intervalId._key : +intervalId;
+
+        if (key >= 100000) {
+            throw new Error("[LeakDetector] 🔄 clearInterval has been called instead of clearTimeout");
         }
         self.clearIntervalCallCount += 1;
 
         if (trace) {
-            console.log("clearInterval " + intervalId, get_stack());
+            console.log("[LeakDetector] 🔄 clearInterval " + key, get_stack());
         }
-        const key = intervalId;
 
         const data = self.interval_map[key];
 
@@ -305,7 +339,7 @@ ResourceLeakDetector.prototype.stop = function(info) {
 
     const self = ResourceLeakDetector.singleton;
     if (trace) {
-        console.log(" stop resourceLeakDetector");
+        console.log("[LeakDetector] stop resourceLeakDetector");
     }
     assert(typeof self.setInterval_old === "function", " did you forget to call resourceLeakDetector.start() ?");
 
@@ -369,10 +403,15 @@ let testHasFailed = false;
 
 exports.installResourceLeakDetector = function(isGlobal, func) {
 
-    const trace = traceFromThisProjectOnly();
+    const _trace = traceFromThisProjectOnly();
     testHasFailed = false;
+
+    let beforeOverallSnapshot;
+    let afterOverallSnapshot;
+    let beforeSnapshot;
+    let afterSnapshot;
     if (isGlobal) {
-        before(function() {
+        before(function(/*this: Mocha.Suite*/) {
             testHasFailed = false;
             resourceLeakDetector.ctx = this.test.ctx;
             resourceLeakDetector.start();
@@ -380,41 +419,58 @@ exports.installResourceLeakDetector = function(isGlobal, func) {
             if (global.gc) {
                 global.gc(true);
             }
+            beforeOverallSnapshot = takeMemorySnapshot();
+
         });
-        beforeEach(function() {
+        beforeEach(() => {
             // make sure we start with a garbage collected situation
             if (global.gc) {
                 global.gc(true);
             }
+            beforeSnapshot = takeMemorySnapshot();
         });
         if (func) {
             func.call(this);
         }
-        after(function() {
+        after(async () => {
+
             resourceLeakDetector.stop({ silent: testHasFailed });
             resourceLeakDetector.ctx = false;
             // make sure we start with a garbage collected situation
             if (global.gc) {
                 global.gc(true);
             }
+            // give some time to relax
+            afterOverallSnapshot = takeMemorySnapshot();
+            checkForMemoryLeak(beforeOverallSnapshot, afterOverallSnapshot);
+
+        });
+        afterEach(async () => {
+            afterSnapshot = takeMemorySnapshot();
+
         });
 
     } else {
-        beforeEach(function() {
+        beforeEach(function(/*this: Mocha.Test*/) {
 
             if (global.gc) {
                 global.gc(true);
             }
             resourceLeakDetector.ctx = this.test.ctx;
             resourceLeakDetector.start();
+            beforeSnapshot = takeMemorySnapshot();
         });
-        afterEach(function() {
+        afterEach(async () => {
             resourceLeakDetector.stop({ silent: testHasFailed });
             resourceLeakDetector.ctx = false;
             // make sure we start with a garbage collected situation
             if (global.gc) {
                 global.gc(true);
             }
+            // give some time to relax
+            await new Promise(resolve => setTimeout(resolve, 200));
+            afterSnapshot = takeMemorySnapshot();
+            checkForMemoryLeak(beforeSnapshot, afterSnapshot);
         });
 
     }
@@ -454,6 +510,11 @@ assert(typeof global_describe === "function", " expecting mocha to be defined");
 
 let g_inDescribeWithLeakDetector = false;
 exports.describeWithLeakDetector = function(message, func) {
+
+    if (memLeakDetectionDisabled) {
+        return global_describe(message, func);
+    }
+
     if (g_inDescribeWithLeakDetector) {
         return global_describe(message, func);
     }