@memlab/core 1.1.9 → 1.1.11

package/dist/lib/Config.d.ts

@@ -206,7 +206,7 @@ export declare class MemLabConfig {
     set isHeadfulBrowser(isHeadful: boolean);
     get isHeadfulBrowser(): boolean;
     get browserBinaryPath(): string;
-    set reportLeaksInTimers(flag: boolean);
+    set reportLeaksInTimers(shouldReport: boolean);
     get reportLeaksInTimers(): boolean;
     setDevice(deviceName: string, options?: {
         manualOverride?: boolean;

package/dist/lib/Config.js

@@ -50,7 +50,7 @@ class MemLabConfig {
     initInternalConfigs() {
         // DO NOT SET PARAMETER HERE
         this._isFullRun = false;
-        this._reportLeaksInTimers = false;
+        this._reportLeaksInTimers = true;
         this._deviceManualOverridden = false;
         this._timerNodes = ['Pending activities'];
         this._timerEdges = [];
@@ -313,7 +313,7 @@ class MemLabConfig {
     static getInstance() {
         if (!MemLabConfig.instance) {
             const config = new MemLabConfig();
-            // do not consider objects kept alive by timers as leaks
+            // consider objects kept alive by timers as leaks
             config.reportLeaksInTimers = true;
             // assign configuration to console manager
             Console_1.default.setConfig(config);
@@ -396,11 +396,8 @@ class MemLabConfig {
     get browserBinaryPath() {
         return path_1.default.join(this.browserDir, this.browser);
     }
-    set reportLeaksInTimers(flag) {
-        if (typeof flag !== 'boolean') {
-            return;
-        }
-        if (flag) {
+    set reportLeaksInTimers(shouldReport) {
+        if (shouldReport) {
             this.removeFromSet(this.nodeNameBlockList, this._timerNodes);
             this.removeFromSet(this.edgeNameBlockList, this._timerEdges);
         }
@@ -408,7 +405,7 @@ class MemLabConfig {
             this.addToSet(this.nodeNameBlockList, this._timerNodes);
             this.addToSet(this.edgeNameBlockList, this._timerEdges);
         }
-        this._reportLeaksInTimers = flag;
+        this._reportLeaksInTimers = shouldReport;
     }
     get reportLeaksInTimers() {
         return this._reportLeaksInTimers;

package/dist/lib/HeapAnalyzer.d.ts

@@ -41,6 +41,14 @@ declare class MemoryAnalyst {
     searchLeakedTraces(leakedNodeIds: HeapNodeIdSet, snapshot: IHeapSnapshot): Promise<{
         paths: LeakTracePathItem[];
     }>;
+    /**
+     * Given a set of heap object ids, cluster them based on the similarity
+     * of their retainer traces and return a
+     * @param leakedNodeIds
+     * @param snapshot
+     * @returns
+     */
+    clusterHeapObjects(objectIds: HeapNodeIdSet, snapshot: IHeapSnapshot): TraceCluster[];
     serializeClusterUpdate(clusters: TraceCluster[], options?: {
         reclusterOnly?: boolean;
     }): Promise<void>;

package/dist/lib/HeapAnalyzer.js

@@ -647,6 +647,7 @@ class MemoryAnalyst {
                     ? new MLTraceSimilarityStrategy_1.default()
                     : undefined,
             });
+            Console_1.default.midLevel(`MemLab found ${clusters.length} leak(s)`);
             yield this.serializeClusterUpdate(clusters);
             if (Config_1.default.logUnclassifiedClusters) {
                 // cluster traces from the current run
@@ -658,6 +659,36 @@ class MemoryAnalyst {
             };
         });
     }
+    /**
+     * Given a set of heap object ids, cluster them based on the similarity
+     * of their retainer traces and return a
+     * @param leakedNodeIds
+     * @param snapshot
+     * @returns
+     */
+    clusterHeapObjects(objectIds, snapshot) {
+        const finder = this.preparePathFinder(snapshot);
+        const paths = [];
+        let i = 0;
+        // analysis for each node
+        Utils_1.default.applyToNodes(objectIds, snapshot, node => {
+            if (++i % 11 === 0) {
+                Console_1.default.overwrite(`progress: ${i} / ${objectIds.size} @${node.id}`);
+            }
+            // BFS search for path from the leaked node to GC roots
+            const p = finder.getPathToGCRoots(snapshot, node);
+            if (p) {
+                paths.push(p);
+            }
+        }, { reverse: true });
+        // cluster traces from the current run
+        const clusters = TraceBucket_1.default.clusterPaths(paths, snapshot, this.aggregateDominatorMetrics, {
+            strategy: Config_1.default.isMLClustering
+                ? new MLTraceSimilarityStrategy_1.default()
+                : undefined,
+        });
+        return clusters;
+    }
     serializeClusterUpdate(clusters, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             // load existing clusters

package/dist/lib/NodeHeap.js

@@ -93,7 +93,7 @@ exports.tagObject = tagObject;
  * ```
  */
 function dumpNodeHeapSnapshot() {
-    const randomID = `Math.random()`.replace('0.', '');
+    const randomID = `${Math.random()}`.replace('0.', '');
     const file = path_1.default.join(FileManager_1.default.generateTmpHeapDir(), `nodejs-${randomID}.heapsnapshot`);
     if (fs_extra_1.default.existsSync(file)) {
         fs_extra_1.default.removeSync(file);

package/dist/lib/Types.d.ts

@@ -431,6 +431,35 @@ export interface IScenario {
      * for memory leak filtering.
      */
     url: () => string;
+    /**
+     * `setup` is the callback function that will be called only once
+     * after the initial page load. This callback can be used to log in
+     * if you have to (we recommend using {@link cookies})
+     * or to prepare data before the {@link action} call.
+     *
+     * * **Parameters**:
+     *   * page: `Page` | the puppeteer [`Page`](https://pptr.dev/api/puppeteer.page)
+     *     object, which provides APIs to interact with the web browser
+     *
+     * * **Examples**:
+     * ```typescript
+     * const scenario = {
+     *   url: () => 'https://www.npmjs.com/',
+     *   setup: async (page) => {
+     *     // log in or prepare data for the interaction
+     *   },
+     *   action: async (page) => {
+     *     await page.click('a[href="/link"]');
+     *   },
+     *   back: async (page) => {
+     *     await page.click('a[href="/back"]');
+     *   },
+     * }
+     *
+     * module.exports = scenario;
+     * ```
+     */
+    setup?: InteractionsCallback;
     /**
      * `action` is the callback function that defines the interaction
      * where you want to trigger memory leaks after the initial page load.
@@ -473,7 +502,7 @@ export interface IScenario {
      * }
      *
      * module.exports = scenario;
-     ```
+     * ```
      */
     action?: InteractionsCallback;
     /**
@@ -728,10 +757,12 @@ export interface IE2EScenarioVisitPlan {
     numOfWarmup: number;
     dataBuilder: Optional<IDataBuilder>;
     isPageLoaded?: CheckPageLoadCallback;
+    scenario?: IScenario;
 }
 /** @internal */
 export declare type OperationArgs = {
     isPageLoaded?: CheckPageLoadCallback;
+    scenario?: Optional<IScenario>;
     showProgress?: boolean;
     failedURLs?: AnyRecord;
     pageHistoryLength?: number[];
@@ -1228,7 +1259,7 @@ export interface IHeapNodeBasic {
  */
 export declare type EdgeIterationCallback = (edge: IHeapEdge) => Optional<{
     stop: boolean;
-}>;
+}> | void;
 /**
  * An `IHeapNode` instance represents a JS heap object in a heap snapshot.
  * A heap snapshot is generally a graph where graph nodes are JS heap objects

package/dist/lib/Utils.d.ts

@@ -22,6 +22,7 @@ declare function isEssentialEdge(nodeIndex: number, edgeType: string, rootNodeIn
 declare function isFiberNodeDeletionsEdge(edge: IHeapEdge): boolean;
 declare function isBlinkRootNode(node: IHeapNode): boolean;
 declare function isPendingActivityNode(node: IHeapNode): boolean;
+declare function isDOMNodeIncomplete(node: IHeapNode): boolean;
 declare function isRootNode(node: IHeapNode, opt?: AnyOptions): boolean;
 declare function isDirectPropEdge(edge: IHeapEdge): boolean;
 declare function isReturnEdge(edge: IHeapEdge): boolean;
@@ -171,6 +172,7 @@ declare const _default: {
     isDetachedDOMNode: typeof isDetachedDOMNode;
     isDirectPropEdge: typeof isDirectPropEdge;
     isDocumentDOMTreesRoot: typeof isDocumentDOMTreesRoot;
+    isDOMNodeIncomplete: typeof isDOMNodeIncomplete;
     isEssentialEdge: typeof isEssentialEdge;
     isFiberNode: typeof isFiberNode;
     isFiberNodeDeletionsEdge: typeof isFiberNodeDeletionsEdge;

package/dist/lib/Utils.js

@@ -212,6 +212,17 @@ function isPendingActivityNode(node) {
     }
     return node.type === 'synthetic' && node.name === 'Pending activities';
 }
+// check the node against a curated list of known HTML Elements
+// the list may be incomplete
+function isDOMNodeIncomplete(node) {
+    let name = node.name;
+    const pattern = /^HTML.*Element$/;
+    const detachedPrefix = 'Detached ';
+    if (name.startsWith(detachedPrefix)) {
+        name = name.substring(detachedPrefix.length);
+    }
+    return pattern.test(name);
+}
 function isRootNode(node, opt = {}) {
     if (!node) {
         return false;
@@ -358,14 +369,16 @@ function getNodesIdSet(snapshot) {
     });
     return set;
 }
-// given a set of nodes S, return a subset S' where
+// given a set of nodes S, return a minimal subset S' where
 // no nodes are dominated by nodes in S
 function getConditionalDominatorIds(ids, snapshot, condCb) {
     const dominatorIds = new Set();
+    const fullDominatorIds = new Set();
     // set all node ids
     applyToNodes(ids, snapshot, node => {
         if (condCb(node)) {
             dominatorIds.add(node.id);
+            fullDominatorIds.add(node.id);
         }
     });
     // traverse the dominators and remove the node
@@ -377,7 +390,7 @@ function getConditionalDominatorIds(ids, snapshot, condCb) {
             if (visited.has(cur.id)) {
                 break;
             }
-            if (dominatorIds.has(cur.id)) {
+            if (fullDominatorIds.has(cur.id)) {
                 dominatorIds.delete(node.id);
                 break;
             }
@@ -1733,6 +1746,7 @@ exports.default = {
     isDetachedDOMNode,
     isDirectPropEdge,
     isDocumentDOMTreesRoot,
+    isDOMNodeIncomplete,
     isEssentialEdge,
     isFiberNode,
     isFiberNodeDeletionsEdge,

package/dist/lib/heap-data/MemLabTagStore.d.ts

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 import type { AnyValue, IHeapSnapshot } from '../Types';
 declare type AnyObject = Record<AnyValue, AnyValue>;

package/dist/lib/heap-data/MemLabTagStore.js

@@ -5,8 +5,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const __1 = require("../..");

package/dist/paths/TraceFinder.js

@@ -388,10 +388,18 @@ class TraceFinder {
     shouldIgnoreEdgeInTraceFinding(edge) {
         const fromNode = edge.fromNode;
         const toNode = edge.toNode;
-        return (Config_1.default.hideBrowserLeak &&
-            (Utils_1.default.isBlinkRootNode(fromNode) ||
-                Utils_1.default.isPendingActivityNode(fromNode)) &&
-            Utils_1.default.isDetachedDOMNode(toNode));
+        const isDetachedNode = Utils_1.default.isDetachedDOMNode(toNode);
+        if (Config_1.default.hideBrowserLeak &&
+            Utils_1.default.isBlinkRootNode(fromNode) &&
+            isDetachedNode) {
+            return true;
+        }
+        if (!Config_1.default.reportLeaksInTimers &&
+            Utils_1.default.isPendingActivityNode(fromNode) &&
+            isDetachedNode) {
+            return true;
+        }
+        return false;
     }
     shouldTraverseEdge(edge, options = {}) {
         if (this.isBlockListedEdge(edge)) {
@@ -411,9 +419,20 @@ class TraceFinder {
         if (Config_1.default.edgeNameBlockList.has(String(nameOrIndex))) {
             return true;
         }
+        if (Config_1.default.nodeNameBlockList.has(edge.toNode.name)) {
+            return true;
+        }
+        if (Config_1.default.nodeNameBlockList.has(edge.fromNode.name)) {
+            return true;
+        }
         return false;
     }
     isLessPreferableEdge(edge) {
+        // pending activities -> DOM element is less preferrable
+        if (Utils_1.default.isPendingActivityNode(edge.fromNode) &&
+            Utils_1.default.isDOMNodeIncomplete(edge.toNode)) {
+            return true;
+        }
         return Config_1.default.edgeNameGreyList.has(String(edge.name_or_index));
     }
     isLessPreferableNode(node) {

package/dist/trace-cluster/TraceBucket.js

@@ -211,12 +211,18 @@ class NormalizedTrace {
         const { allClusters } = NormalizedTrace.diffTraces(traces, [], option);
         // construct TraceCluster from clustering result
         let clusters = allClusters.map((traces) => {
+            const representativeTrace = traces[0];
             const cluster = {
-                path: traceToPathMap.get(traces[0]),
+                path: traceToPathMap.get(representativeTrace),
                 count: traces.length,
                 snapshot,
                 retainedSize: 0,
             };
+            // add representative object id if there is one
+            const lastNode = representativeTrace[representativeTrace.length - 1];
+            if ('id' in lastNode) {
+                cluster.id = lastNode.id;
+            }
             traces.forEach((trace) => {
                 NormalizedTrace.addLeakedNodeToCluster(cluster, traceToPathMap.get(trace));
             });
@@ -225,7 +231,6 @@ class NormalizedTrace {
         });
         clusters = NormalizedTrace.filterClusters(clusters);
         clusters.sort((c1, c2) => { var _a, _b; return ((_a = c2.retainedSize) !== null && _a !== void 0 ? _a : 0) - ((_b = c1.retainedSize) !== null && _b !== void 0 ? _b : 0); });
-        Console_1.default.midLevel(`MemLab found ${clusters.length} leak(s)`);
         return clusters;
     }
     static generateUnClassifiedClusters(paths, snapshot, aggregateDominatorMetrics) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/core",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "license": "MIT",
   "description": "memlab core libraries",
   "author": "Liang Gong <lgong@fb.com>",