node-opcua-leak-detector 2.168.0 → 2.172.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-leak-detector",
-    "version": "2.168.0",
+    "version": "2.172.0",
     "description": "pure nodejs OPCUA SDK - module leak-detector",
     "main": "index.js",
     "types": "index.d.ts",
@@ -24,14 +24,14 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "653b6d6df801ca17298308089dee32e5b12102b6",
+    "gitHead": "dfe9993a93b5c3897825e898b5f07b25952c7f45",
     "files": [
         "src"
     ],
     "dependencies": {
         "chalk": "4.1.2",
         "node-opcua-assert": "2.164.0",
-        "node-opcua-object-registry": "2.168.0",
+        "node-opcua-object-registry": "2.172.0",
         "wtfnode": "^0.10.1"
     }
 }

package/src/mem_leak_detector.js

@@ -1,31 +1,33 @@
 // memoryLeakDetector.js
 let wtf;
 
-
 if (process.env.MEM_LEAK_DETECTION_WTF_ENABLED) {
-  console.log("[LeakDetector] ⚠️ WTFNODE enabled");
-  wtf = require('wtfnode');
-  wtf.init();
+    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.");
+    console.log("[LeakDetector] ℹ️  WTFNODE disabled. Use MEM_LEAK_DETECTION_WTF_ENABLED=true to enable it.");
 }
 
-
-let noGCexposed = undefined;
+let noGCexposed;
 
 /**
  * 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.');
+    if (global.gc) {
+        // Major GC: thorough enough that callers don't need to invoke a separate
+        // global.gc(true) themselves before calling takeMemorySnapshot.
+        global.gc(true);
+        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;
     }
-    noGCexposed = true;
-  }
 }
 
 /**
@@ -33,11 +35,18 @@ function forceGC() {
  * @returns {number} Heap used in bytes.
  */
 function takeMemorySnapshot() {
-  if (noGCexposed) {
-    return;
-  }
-  forceGC();
-  return process.memoryUsage().heapUsed;
+    if (noGCexposed) {
+        return;
+    }
+    const { performance } = require("node:perf_hooks");
+    const start = performance.now();
+    forceGC();
+    const end = performance.now();
+    const duration = (end - start).toFixed(2);
+    if (duration > 1) {
+        console.log(`[LeakDetector] ♻️  Garbage collection took ${duration}ms`);
+    }
+    return process.memoryUsage().heapUsed;
 }
 
 /**
@@ -48,29 +57,27 @@ function takeMemorySnapshot() {
  * @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 (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`
-    );
-  }
-
+    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.
+    wtf?.dump({ fullStacks: true }); // Show open handles, listeners, etc.
 
-  return { before: heapUsedBefore, after: heapUsedAfter, delta, isLeak };
+    return { before: heapUsedBefore, after: heapUsedAfter, delta, isLeak };
 }
 
-module.exports = { takeMemorySnapshot, checkForMemoryLeak };
+module.exports = { takeMemorySnapshot, checkForMemoryLeak };

package/src/resource_leak_detector.js

@@ -477,10 +477,8 @@ exports.installResourceLeakDetector = function(isGlobal, func) {
 
         });
         beforeEach(() => {
-            // make sure we start with a garbage collected situation
-            if (global.gc) {
-                global.gc(true);
-            }
+            // takeMemorySnapshot now does its own major GC; no need for an
+            // explicit gc(true) here. Saves one ~100ms major-GC stall per test.
             beforeSnapshot = takeMemorySnapshot();
         });
         if (func) {
@@ -506,10 +504,7 @@ exports.installResourceLeakDetector = function(isGlobal, func) {
 
     } else {
         beforeEach(function(/*this: Mocha.Test*/) {
-
-            if (global.gc) {
-                global.gc(true);
-            }
+            // takeMemorySnapshot now does its own major GC; no separate gc(true) here.
             resourceLeakDetector.ctx = this.test.ctx;
             resourceLeakDetector.start();
             beforeSnapshot = takeMemorySnapshot();