@memlab/core 1.0.8 → 1.1.1

package/dist/index.d.ts

@@ -8,22 +8,39 @@
  * @format
  */
 export * from './lib/Types';
+/** @internal */
 export { default as config } from './lib/Config';
+/** @internal */
 export * from './lib/InternalValueSetter';
+/** @internal */
 export * from './lib/Config';
+/** @internal */
 export { default as info } from './lib/Console';
+/** @internal */
 export { default as BaseOption } from './lib/BaseOption';
+/** @internal */
 export { default as utils } from './lib/Utils';
+/** @internal */
 export { default as fileManager } from './lib/FileManager';
+/** @internal */
 export * from './lib/FileManager';
+/** @internal */
 export { default as serializer } from './lib/Serializer';
+/** @internal */
 export { default as browserInfo } from './lib/BrowserInfo';
+/** @internal */
 export { default as analysis } from './lib/HeapAnalyzer';
+/** @internal */
 export { default as constant } from './lib/Constant';
+/** @internal */
 export { default as modes } from './modes/RunningModes';
+/** @internal */
 export { default as ProcessManager } from './lib/ProcessManager';
+/** @internal */
 export { default as leakClusterLogger } from './logger/LeakClusterLogger';
+/** @internal */
 export { default as NormalizedTrace } from './trace-cluster/TraceBucket';
+/** @internal */
 export { default as EvaluationMetric } from './trace-cluster/EvalutationMetric';
 export * from './lib/NodeHeap';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -28,35 +28,52 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvaluationMetric = exports.NormalizedTrace = exports.leakClusterLogger = exports.ProcessManager = exports.modes = exports.constant = exports.analysis = exports.browserInfo = exports.serializer = exports.fileManager = exports.utils = exports.BaseOption = exports.info = exports.config = void 0;
 __exportStar(require("./lib/Types"), exports);
+/** @internal */
 var Config_1 = require("./lib/Config");
 Object.defineProperty(exports, "config", { enumerable: true, get: function () { return __importDefault(Config_1).default; } });
+/** @internal */
 __exportStar(require("./lib/InternalValueSetter"), exports);
+/** @internal */
 __exportStar(require("./lib/Config"), exports);
+/** @internal */
 var Console_1 = require("./lib/Console");
 Object.defineProperty(exports, "info", { enumerable: true, get: function () { return __importDefault(Console_1).default; } });
+/** @internal */
 var BaseOption_1 = require("./lib/BaseOption");
 Object.defineProperty(exports, "BaseOption", { enumerable: true, get: function () { return __importDefault(BaseOption_1).default; } });
+/** @internal */
 var Utils_1 = require("./lib/Utils");
 Object.defineProperty(exports, "utils", { enumerable: true, get: function () { return __importDefault(Utils_1).default; } });
+/** @internal */
 var FileManager_1 = require("./lib/FileManager");
 Object.defineProperty(exports, "fileManager", { enumerable: true, get: function () { return __importDefault(FileManager_1).default; } });
+/** @internal */
 __exportStar(require("./lib/FileManager"), exports);
+/** @internal */
 var Serializer_1 = require("./lib/Serializer");
 Object.defineProperty(exports, "serializer", { enumerable: true, get: function () { return __importDefault(Serializer_1).default; } });
+/** @internal */
 var BrowserInfo_1 = require("./lib/BrowserInfo");
 Object.defineProperty(exports, "browserInfo", { enumerable: true, get: function () { return __importDefault(BrowserInfo_1).default; } });
+/** @internal */
 var HeapAnalyzer_1 = require("./lib/HeapAnalyzer");
 Object.defineProperty(exports, "analysis", { enumerable: true, get: function () { return __importDefault(HeapAnalyzer_1).default; } });
+/** @internal */
 var Constant_1 = require("./lib/Constant");
 Object.defineProperty(exports, "constant", { enumerable: true, get: function () { return __importDefault(Constant_1).default; } });
+/** @internal */
 var RunningModes_1 = require("./modes/RunningModes");
 Object.defineProperty(exports, "modes", { enumerable: true, get: function () { return __importDefault(RunningModes_1).default; } });
+/** @internal */
 var ProcessManager_1 = require("./lib/ProcessManager");
 Object.defineProperty(exports, "ProcessManager", { enumerable: true, get: function () { return __importDefault(ProcessManager_1).default; } });
+/** @internal */
 var LeakClusterLogger_1 = require("./logger/LeakClusterLogger");
 Object.defineProperty(exports, "leakClusterLogger", { enumerable: true, get: function () { return __importDefault(LeakClusterLogger_1).default; } });
+/** @internal */
 var TraceBucket_1 = require("./trace-cluster/TraceBucket");
 Object.defineProperty(exports, "NormalizedTrace", { enumerable: true, get: function () { return __importDefault(TraceBucket_1).default; } });
+/** @internal */
 var EvalutationMetric_1 = require("./trace-cluster/EvalutationMetric");
 Object.defineProperty(exports, "EvaluationMetric", { enumerable: true, get: function () { return __importDefault(EvalutationMetric_1).default; } });
 __exportStar(require("./lib/NodeHeap"), exports);

package/dist/lib/Config.d.ts

@@ -37,10 +37,12 @@ interface Device {
 declare type ConfigOption = {
     workDir?: string;
 };
+/** @internal */
 export declare enum ErrorHandling {
     Halt = 1,
     Throw = 2
 }
+/** @internal */
 export declare class MemLabConfig {
     snapshotHasDetachedness: boolean;
     specifiedEngine: boolean;
@@ -137,6 +139,7 @@ export declare class MemLabConfig {
     waitAfterOperation: number;
     waitAfterScrolling: number;
     waitAfterTyping: number;
+    waitForNetworkInDefaultScenario: number;
     stressTestRepeat: number;
     avoidLeakWithoutDetachedElements: boolean;
     hideBrowserLeak: boolean;
@@ -165,6 +168,7 @@ export declare class MemLabConfig {
     nodeIgnoreSetInShape: Set<string>;
     oversizeObjectAsLeak: boolean;
     oversizeThreshold: number;
+    clusterRetainedSizeThreshold: number;
     _isFullRun: boolean;
     _scenario: Optional<IScenario>;
     externalLeakFilter?: Optional<ILeakFilter>;
@@ -199,8 +203,8 @@ export declare class MemLabConfig {
     enableXvfb(display: string): void;
     disableXvfb(): void;
 }
-/** @ignore */
+/** @internal */
 declare const config: MemLabConfig;
-/** @ignore */
+/** @internal */
 export default config;
 //# sourceMappingURL=Config.d.ts.map

package/dist/lib/Config.js

@@ -33,11 +33,13 @@ const defaultViewport = {
     height: windowHeight,
     deviceScaleFactor: 1,
 };
+/** @internal */
 var ErrorHandling;
 (function (ErrorHandling) {
     ErrorHandling[ErrorHandling["Halt"] = 1] = "Halt";
     ErrorHandling[ErrorHandling["Throw"] = 2] = "Throw";
 })(ErrorHandling = exports.ErrorHandling || (exports.ErrorHandling = {}));
+/** @internal */
 class MemLabConfig {
     constructor(options = {}) {
         // init properties, they can be configured manually
@@ -47,6 +49,7 @@ class MemLabConfig {
     }
     initInternalConfigs() {
         // DO NOT SET PARAMETER HERE
+        this._isFullRun = false;
         this._reportLeaksInTimers = false;
         this._deviceManualOverridden = false;
         this._timerNodes = ['Pending activities'];
@@ -189,6 +192,8 @@ class MemLabConfig {
         this.waitAfterScrolling = 5000;
         // extra delay after typing
         this.waitAfterTyping = 1000;
+        // page load checker: default wait for network idle in scenario test
+        this.waitForNetworkInDefaultScenario = 10000;
         // default repeat for stress testing
         this.stressTestRepeat = 5;
         // only show leaks with detached HTML elements
@@ -239,6 +244,7 @@ class MemLabConfig {
         this.nodeNameGreyList = new Set([
             'InternalNode',
             'Pending activities',
+            'StyleEngine',
             ...Constant_1.default.V8SyntheticRoots,
         ]);
         // edge names less preferable in trace finding
@@ -266,6 +272,9 @@ class MemLabConfig {
         this.oversizeObjectAsLeak = false;
         // if larger than this threshold, consider as memory leak
         this.oversizeThreshold = 0;
+        // only report leak clusters with aggregated retained size
+        // bigger than this threshold
+        this.clusterRetainedSizeThreshold = 0;
         // initialize file and directory paths
         FileManager_1.default.initDirs(this, options);
     }
@@ -424,8 +433,8 @@ class MemLabConfig {
     }
 }
 exports.MemLabConfig = MemLabConfig;
-/** @ignore */
+/** @internal */
 const config = MemLabConfig.getInstance();
 (0, InternalValueSetter_1.setInternalValue)(config, __filename, Constant_1.default.internalDir);
-/** @ignore */
+/** @internal */
 exports.default = config;

package/dist/lib/FileManager.d.ts

@@ -9,11 +9,13 @@
  */
 import type { MemLabConfig } from './Config';
 import type { AnyValue, Optional } from './Types';
+/** @internal */
 export declare type FileOption = {
     workDir?: Optional<string>;
     clear?: boolean;
     transcient?: boolean;
 };
+/** @internal */
 export declare class FileManager {
     getDefaultWorkDir(): string;
     generateTmpHeapDir(): string;

package/dist/lib/FileManager.js

@@ -35,6 +35,7 @@ function joinAndProcessDir(options, ...args) {
     }
     return filepath;
 }
+/** @internal */
 class FileManager {
     getDefaultWorkDir() {
         return path_1.default.join(this.getTmpDir(), 'memlab');

package/dist/lib/HeapAnalyzer.d.ts

@@ -27,8 +27,6 @@ declare class MemoryAnalyst {
     preparePathFinder(snapshot: IHeapSnapshot): TraceFinder;
     private dumpPageInteractionSummary;
     private dumpLeakSummaryToConsole;
-    private checkDetachedFiberNode;
-    private isTrivialNode;
     private filterLeakedObjects;
     aggregateDominatorMetrics(ids: HeapNodeIdSet, snapshot: IHeapSnapshot, checkNodeCb: (node: IHeapNode) => boolean, nodeMetricsCb: (node: IHeapNode) => number): number;
     private getOverallHeapInfo;
@@ -38,6 +36,8 @@ declare class MemoryAnalyst {
     private breakDownSnapshotByShapes;
     private isTrivialEdgeForBreakDown;
     private breakDownByReferrers;
+    private printHeapAndLeakInfo;
+    private logLeakTraceSummary;
     searchLeakedTraces(leakedNodeIds: HeapNodeIdSet, snapshot: IHeapSnapshot): Promise<{
         paths: LeakTracePathItem[];
     }>;

package/dist/lib/HeapAnalyzer.js

@@ -32,6 +32,7 @@ const Config_1 = __importDefault(require("./Config"));
 const Console_1 = __importDefault(require("./Console"));
 const Serializer_1 = __importDefault(require("./Serializer"));
 const Utils_1 = __importDefault(require("./Utils"));
+const LeakObjectFilter_1 = require("./leak-filters/LeakObjectFilter");
 class MemoryAnalyst {
     checkLeak() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -416,53 +417,15 @@ class MemoryAnalyst {
         Console_1.default.topLevel('Alive objects allocated in target page:');
         Console_1.default.table(list);
     }
-    checkDetachedFiberNode(node) {
-        if (!Config_1.default.detectFiberNodeLeak ||
-            !Utils_1.default.isFiberNode(node) ||
-            Utils_1.default.hasHostRoot(node)) {
-            return false;
-        }
-        return !Utils_1.default.isNodeDominatedByDeletionsArray(node);
-    }
-    isTrivialNode(node) {
-        return (node.type === 'number' ||
-            Utils_1.default.isStringNode(node) ||
-            node.type === 'hidden');
-    }
     filterLeakedObjects(leakedNodeIds, snapshot) {
         var _a;
         // call init leak filter hook if exists
         if ((_a = Config_1.default.externalLeakFilter) === null || _a === void 0 ? void 0 : _a.beforeLeakFilter) {
             Config_1.default.externalLeakFilter.beforeLeakFilter(snapshot, leakedNodeIds);
         }
+        const leakFilter = new LeakObjectFilter_1.LeakObjectFilter();
         // start filtering memory leaks
-        Utils_1.default.filterNodesInPlace(leakedNodeIds, snapshot, node => {
-            // use external leak filter if exists
-            if (Config_1.default.externalLeakFilter) {
-                return Config_1.default.externalLeakFilter.leakFilter(node, snapshot, leakedNodeIds);
-            }
-            if (this.isTrivialNode(node)) {
-                return false;
-            }
-            // when analyzing hermes heap snapshots, filter Hermes internal objects
-            if (Config_1.default.jsEngine === 'hermes' && Utils_1.default.isHermesInternalObject(node)) {
-                return false;
-            }
-            if (Config_1.default.oversizeObjectAsLeak) {
-                return node.retainedSize > Config_1.default.oversizeThreshold;
-            }
-            // check FiberNodes without a Fiber Root
-            if (this.checkDetachedFiberNode(node)) {
-                return true;
-            }
-            const isDetached = Utils_1.default.isDetachedDOMNode(node, {
-                ignoreInternalNode: true,
-            });
-            if (isDetached && Config_1.default.targetApp === 'ads-manager') {
-                return Utils_1.default.hasReactEdges(node);
-            }
-            return isDetached || Utils_1.default.isStackTraceFrame(node);
-        });
+        Utils_1.default.filterNodesInPlace(leakedNodeIds, snapshot, node => leakFilter.filter(Config_1.default, node, snapshot, leakedNodeIds));
         if (Config_1.default.verbose) {
             Console_1.default.midLevel(`${leakedNodeIds.size} Fiber nodes and Detached elements`);
         }
@@ -615,29 +578,40 @@ class MemoryAnalyst {
             .join('\n');
         return referrerInfo;
     }
+    printHeapAndLeakInfo(leakedNodeIds, snapshot) {
+        // write page interaction summary to the leaks text file
+        this.dumpPageInteractionSummary();
+        // dump leak summry to console
+        this.dumpLeakSummaryToConsole(leakedNodeIds, snapshot);
+        // get aggregated leak info
+        const heapInfo = this.getOverallHeapInfo(snapshot);
+        if (heapInfo) {
+            this.printHeapInfo(heapInfo);
+        }
+    }
+    logLeakTraceSummary(trace, nodeIdInPaths, snapshot) {
+        if (!Config_1.default.isFullRun) {
+            return;
+        }
+        // convert the path to a string
+        const pathStr = Serializer_1.default.summarizePath(trace, nodeIdInPaths, snapshot);
+        fs_1.default.appendFileSync(Config_1.default.exploreResultFile, `\n\n${pathStr}\n\n`, 'UTF-8');
+    }
     // find unique paths of leaked nodes
     searchLeakedTraces(leakedNodeIds, snapshot) {
         return __awaiter(this, void 0, void 0, function* () {
             const finder = this.preparePathFinder(snapshot);
-            // write page interaction summary to the leaks text file
-            this.dumpPageInteractionSummary();
-            // dump leak summry to console
-            this.dumpLeakSummaryToConsole(leakedNodeIds, snapshot);
+            this.printHeapAndLeakInfo(leakedNodeIds, snapshot);
             // get all leaked objects
             this.filterLeakedObjects(leakedNodeIds, snapshot);
-            // get aggregated leak info
-            const leakInfo = this.getOverallHeapInfo(snapshot);
-            if (leakInfo) {
-                this.printHeapInfo(leakInfo);
-            }
             if (Config_1.default.verbose) {
                 // show a breakdown of different object structures
                 this.breakDownSnapshotByShapes(snapshot);
             }
-            let numOfLeakedObjects = 0;
-            let i = 0;
             const nodeIdInPaths = new Set();
             const paths = [];
+            let numOfLeakedObjects = 0;
+            let i = 0;
             // analysis for each node
             Utils_1.default.applyToNodes(leakedNodeIds, snapshot, node => {
                 if (!Config_1.default.isContinuousTest && ++i % 11 === 0) {
@@ -645,19 +619,12 @@ class MemoryAnalyst {
                 }
                 // BFS search for path from the leaked node to GC roots
                 const p = finder.getPathToGCRoots(snapshot, node);
-                if (!p) {
-                    return;
-                }
-                if (!Utils_1.default.isInterestingPath(p)) {
+                if (!p || !Utils_1.default.isInterestingPath(p)) {
                     return;
                 }
                 ++numOfLeakedObjects;
                 paths.push(p);
-                // convert the path to a string
-                if (Config_1.default.isFullRun) {
-                    const pathStr = Serializer_1.default.summarizePath(p, nodeIdInPaths, snapshot);
-                    fs_1.default.appendFileSync(Config_1.default.exploreResultFile, `\n\n${pathStr}\n\n`, 'UTF-8');
-                }
+                this.logLeakTraceSummary(p, nodeIdInPaths, snapshot);
             }, { reverse: true });
             if (Config_1.default.verbose) {
                 Console_1.default.midLevel(`${numOfLeakedObjects} leaked objects`);

package/dist/lib/InternalValueSetter.d.ts

@@ -7,8 +7,10 @@
  * @emails oncall+ws_labs
  * @format
  */
+/** @internal */
 export declare abstract class InternalValueSetter<T> {
     fillIn(_module: T): T;
 }
+/** @internal */
 export declare function setInternalValue<T>(value: T, callerFilePath: string, internalFolderName: string): T;
 //# sourceMappingURL=InternalValueSetter.d.ts.map

package/dist/lib/InternalValueSetter.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setInternalValue = exports.InternalValueSetter = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+/** @internal */
 class InternalValueSetter {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     fillIn(_module) {
@@ -22,6 +23,7 @@ class InternalValueSetter {
     }
 }
 exports.InternalValueSetter = InternalValueSetter;
+/** @internal */
 function setInternalValue(value, callerFilePath, internalFolderName) {
     const callerDir = path_1.default.dirname(callerFilePath);
     const callerFile = path_1.default.basename(callerFilePath);