@memlab/core 1.1.21 → 1.1.22

package/dist/lib/Config.d.ts

@@ -38,6 +38,11 @@ declare type ConfigOption = {
     workDir?: string;
 };
 /** @internal */
+export declare enum TraceObjectMode {
+    Default = 1,
+    SelectedJSObjects = 2
+}
+/** @internal */
 export declare enum ErrorHandling {
     Halt = 1,
     Throw = 2
@@ -177,6 +182,7 @@ export declare class MemLabConfig {
     nodeIgnoreSetInShape: Set<string>;
     oversizeObjectAsLeak: boolean;
     oversizeThreshold: number;
+    traceAllObjectsMode: TraceObjectMode;
     clusterRetainedSizeThreshold: number;
     externalLeakFilter?: Optional<ILeakFilter>;
     monoRepoDir: string;
@@ -199,6 +205,9 @@ export declare class MemLabConfig {
     interceptScript: boolean;
     isAnalyzingMainThread: boolean;
     targetWorkerTitle: Nullable<string>;
+    noReCluster: boolean;
+    maxSamplesForClustering: number;
+    filterTraceByName: Nullable<string>;
     constructor(options?: ConfigOption);
     private initInternalConfigs;
     private init;

package/dist/lib/Config.js

@@ -35,7 +35,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemLabConfig = exports.ErrorHandling = void 0;
+exports.MemLabConfig = exports.ErrorHandling = exports.TraceObjectMode = void 0;
 const path_1 = __importDefault(require("path"));
 const RunningModes_1 = __importDefault(require("../modes/RunningModes"));
 const Console_1 = __importDefault(require("./Console"));
@@ -57,6 +57,12 @@ const defaultViewport = {
     deviceScaleFactor: 1,
 };
 /** @internal */
+var TraceObjectMode;
+(function (TraceObjectMode) {
+    TraceObjectMode[TraceObjectMode["Default"] = 1] = "Default";
+    TraceObjectMode[TraceObjectMode["SelectedJSObjects"] = 2] = "SelectedJSObjects";
+})(TraceObjectMode = exports.TraceObjectMode || (exports.TraceObjectMode = {}));
+/** @internal */
 var ErrorHandling;
 (function (ErrorHandling) {
     ErrorHandling[ErrorHandling["Halt"] = 1] = "Halt";
@@ -176,12 +182,17 @@ class MemLabConfig {
         // if true, split dataset into trunks
         // with random order for sequential clustering
         this.seqClusteringIsRandomChunks = false;
+        // maximum number of samples as input for leak trace clustering
+        this.maxSamplesForClustering = 5000;
         // extra E2E run info (other than the fields defined in
         // RunMetaInfo like app, interaction, browserInfo).
         // Information saved in this map will be
         // auto-serialized to run-meta.json when the file is saved
         // and auto-deserialized from run-meta.json when the file is loaded
         this.extraRunInfoMap = new Map();
+        // if specified via CLI options, this will filter leak traces by
+        // node and edge names in the leak trace
+        this.filterTraceByName = null;
     }
     // initialize configurable parameters
     init(options = {}) {
@@ -209,6 +220,8 @@ class MemLabConfig {
         this.skipGC = false;
         // true if running in ContinuousTest
         this.isContinuousTest = false;
+        // true if reclustering is turned off
+        this.noReCluster = false;
         // true if running a local test
         this.isTest = false;
         // true if running in local puppeteer mode
@@ -341,6 +354,9 @@ class MemLabConfig {
         this.oversizeObjectAsLeak = false;
         // if larger than this threshold, consider as memory leak
         this.oversizeThreshold = 0;
+        // when specified default, this mode will trace/diff all objects
+        // you can specified other modes (e.g., selected JS objects only)
+        this.traceAllObjectsMode = TraceObjectMode.Default;
         // only report leak clusters with aggregated retained size
         // bigger than this threshold
         this.clusterRetainedSizeThreshold = 0;

package/dist/lib/Constant.js

@@ -46,6 +46,7 @@ const constants = {
         '(Write barrier)',
         '(Retain maps)',
         '(Unknown)',
+        '<Synthetic>',
     ],
     namePrefixForScenarioFromFile: '',
     unset: 'UNSET',

package/dist/lib/HeapAnalyzer.js

@@ -35,6 +35,7 @@ const TraceBucket_1 = __importDefault(require("../trace-cluster/TraceBucket"));
 const LeakObjectFilter_1 = require("./leak-filters/LeakObjectFilter");
 const MLTraceSimilarityStrategy_1 = __importDefault(require("../trace-cluster/strategies/MLTraceSimilarityStrategy"));
 const LeakTraceFilter_1 = require("./trace-filters/LeakTraceFilter");
+const TraceSampler_1 = __importDefault(require("./TraceSampler"));
 class MemoryAnalyst {
     checkLeak() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -357,26 +358,35 @@ class MemoryAnalyst {
         this.filterLeakedObjects(leakedNodeIds, snapshot);
         const leakTraceFilter = new LeakTraceFilter_1.LeakTraceFilter();
         const nodeIdInPaths = new Set();
-        const paths = [];
-        let numOfLeakedObjects = 0;
-        let i = 0;
+        const samplePool = [];
         // analysis for each node
         Utils_1.default.applyToNodes(leakedNodeIds, snapshot, node => {
-            if (!Config_1.default.isContinuousTest && ++i % 11 === 0) {
-                Console_1.default.overwrite(`progress: ${i} / ${leakedNodeIds.size} @${node.id}`);
-            }
             // BFS search for path from the leaked node to GC roots
             const p = finder.getPathToGCRoots(snapshot, node);
             if (p == null ||
                 !leakTraceFilter.filter(p, { config: Config_1.default, leakedNodeIds, snapshot })) {
                 return;
             }
-            ++numOfLeakedObjects;
-            paths.push(p);
-            this.logLeakTraceSummary(p, nodeIdInPaths, snapshot, options);
+            // filter leak trace based on CLI-specified node or edge names
+            if (!Utils_1.default.pathHasNodeOrEdgeWithName(p, Config_1.default.filterTraceByName)) {
+                return;
+            }
+            // ignore if the leak trace is too long
+            if (Utils_1.default.getLeakTracePathLength(p) > 100) {
+                return;
+            }
+            samplePool.push(p);
         }, { reverse: true });
+        const sampler = new TraceSampler_1.default(samplePool.length);
+        const paths = samplePool.filter(p => {
+            if (sampler.sample()) {
+                this.logLeakTraceSummary(p, nodeIdInPaths, snapshot, options);
+                return true;
+            }
+            return false;
+        });
         if (Config_1.default.verbose) {
-            Console_1.default.midLevel(`${numOfLeakedObjects} leaked objects`);
+            Console_1.default.midLevel(`Filter and select ${paths.length} leaked trace`);
         }
         return paths;
     }
@@ -410,11 +420,11 @@ class MemoryAnalyst {
     clusterHeapObjects(objectIds, snapshot) {
         const finder = this.preparePathFinder(snapshot);
         const paths = [];
-        let i = 0;
+        const sampler = new TraceSampler_1.default(objectIds.size);
         // 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}`);
+            if (!sampler.sample()) {
+                return;
             }
             // BFS search for path from the leaked node to GC roots
             const p = finder.getPathToGCRoots(snapshot, node);

package/dist/lib/TraceSampler.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+export declare type TraceSamplerOption = {
+    maxSample?: number;
+};
+export default class TraceSampler {
+    private maxCount;
+    private processed;
+    private selected;
+    private population;
+    constructor(n: number, options?: TraceSamplerOption);
+    init(n: number): void;
+    private calculateSampleRatio;
+    /**
+     * The caller decide to give up sampling this time.
+     * This `giveup` and the `sample` method in aggregation should be
+     * called `this.population` times.
+     *
+     * For example, if `giveup` is called n1 times,
+     * and `sample` is called n2 times, then n1 + n2 === this.population.
+     */
+    giveup(): void;
+    /**
+     * This sample method should be called precisely this.population times.
+     * @returns true if this sample should be taken
+     */
+    sample(): boolean;
+}
+//# sourceMappingURL=TraceSampler.d.ts.map

package/dist/lib/TraceSampler.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Config_1 = __importDefault(require("./Config"));
+const Console_1 = __importDefault(require("./Console"));
+const Utils_1 = __importDefault(require("./Utils"));
+class TraceSampler {
+    constructor(n, options = {}) {
+        var _a;
+        // the max number of traces after sampling
+        this.maxCount = Config_1.default.maxSamplesForClustering;
+        this.processed = 0;
+        this.selected = 0;
+        this.population = -1;
+        this.maxCount = (_a = options.maxSample) !== null && _a !== void 0 ? _a : Config_1.default.maxSamplesForClustering;
+        this.init(n);
+    }
+    init(n) {
+        this.processed = 0;
+        this.selected = 0;
+        this.population = n;
+        this.calculateSampleRatio(n);
+    }
+    calculateSampleRatio(n) {
+        const sampleRatio = Math.min(1, this.maxCount / n);
+        if (sampleRatio < 1) {
+            Console_1.default.warning('Sampling trace due to a large number of traces:');
+            Console_1.default.lowLevel(` Number of Traces: ${n}`);
+            Console_1.default.lowLevel(` Sampling Ratio: ${Utils_1.default.getReadablePercent(sampleRatio)}`);
+        }
+        return sampleRatio;
+    }
+    /**
+     * The caller decide to give up sampling this time.
+     * This `giveup` and the `sample` method in aggregation should be
+     * called `this.population` times.
+     *
+     * For example, if `giveup` is called n1 times,
+     * and `sample` is called n2 times, then n1 + n2 === this.population.
+     */
+    giveup() {
+        ++this.processed;
+    }
+    /**
+     * This sample method should be called precisely this.population times.
+     * @returns true if this sample should be taken
+     */
+    sample() {
+        if (this.processed >= this.population) {
+            throw Utils_1.default.haltOrThrow(`processing ${this.processed + 1} samples but total population is ${this.population}`);
+        }
+        // use large number to mod here to avoid too much console I/O
+        if (!Config_1.default.isContinuousTest && this.processed % 771 === 0) {
+            const percent = Utils_1.default.getReadablePercent(this.processed / this.population);
+            Console_1.default.overwrite(`progress: ${this.processed} / ${this.population} (${percent})`);
+        }
+        const dynamicRatio = (this.maxCount - this.selected) / (this.population - this.processed);
+        // increase the counter indicating how many samples has been processed
+        ++this.processed;
+        if (Math.random() <= dynamicRatio) {
+            ++this.selected;
+            return true;
+        }
+        return false;
+    }
+}
+exports.default = TraceSampler;

package/dist/lib/Types.d.ts

@@ -1971,4 +1971,9 @@ export interface IHeapConfig {
 }
 /** @internal */
 export declare type ErrorWithMessage = Pick<Error, 'message'>;
+/** @internal */
+export declare type CommandOptionExample = string | {
+    description?: string;
+    cliOptionExample: string;
+};
 //# sourceMappingURL=Types.d.ts.map

package/dist/lib/Utils.d.ts

@@ -28,6 +28,7 @@ declare function isDOMNodeIncomplete(node: IHeapNode): boolean;
 declare function isXMLDocumentNode(node: IHeapNode): boolean;
 declare function isHTMLDocumentNode(node: IHeapNode): boolean;
 declare function isDOMTextNode(node: IHeapNode): boolean;
+declare function isCppRootsNode(node: IHeapNode): boolean;
 declare function isRootNode(node: IHeapNode, opt?: AnyOptions): boolean;
 declare function isDirectPropEdge(edge: IHeapEdge): boolean;
 declare function isReturnEdge(edge: IHeapEdge): boolean;
@@ -75,6 +76,8 @@ declare function isObjectNode(node: IHeapNode): boolean;
 declare function isPlainJSObjectNode(node: IHeapNode): boolean;
 declare function pathHasDetachedHTMLNode(path: LeakTracePathItem): boolean;
 declare function pathHasEdgeWithIndex(path: LeakTracePathItem, idx: number): boolean;
+declare function pathHasEdgeWithName(path: LeakTracePathItem, edgeName: string): boolean;
+declare function pathHasNodeOrEdgeWithName(path: LeakTracePathItem, name: Optional<string>): boolean;
 declare function getLastNodeId(path: LeakTracePathItem): number;
 declare function getReadablePercent(num: number): string;
 declare function getReadableBytes(bytes: Optional<number>): string;
@@ -183,6 +186,7 @@ declare const _default: {
     hasReactEdges: typeof hasReactEdges;
     isAlternateNode: typeof isAlternateNode;
     isBlinkRootNode: typeof isBlinkRootNode;
+    isCppRootsNode: typeof isCppRootsNode;
     isDOMInternalNode: typeof isDOMInternalNode;
     isDOMNodeIncomplete: typeof isDOMNodeIncomplete;
     isDOMTextNode: typeof isDOMTextNode;
@@ -230,6 +234,8 @@ declare const _default: {
     objectToMap: typeof objectToMap;
     pathHasDetachedHTMLNode: typeof pathHasDetachedHTMLNode;
     pathHasEdgeWithIndex: typeof pathHasEdgeWithIndex;
+    pathHasEdgeWithName: typeof pathHasEdgeWithName;
+    pathHasNodeOrEdgeWithName: typeof pathHasNodeOrEdgeWithName;
     repeat: typeof repeat;
     resolveFilePath: typeof resolveFilePath;
     resolveSnapshotFilePath: typeof resolveSnapshotFilePath;

package/dist/lib/Utils.js

@@ -271,6 +271,10 @@ function isHTMLDocumentNode(node) {
 function isDOMTextNode(node) {
     return node.type === 'native' && node.name === 'Text';
 }
+// check if this is a [C++ roots] (synthetic) node
+function isCppRootsNode(node) {
+    return node.name === 'C++ roots' && node.type === 'synthetic';
+}
 function isRootNode(node, opt = {}) {
     if (!node) {
         return false;
@@ -499,7 +503,7 @@ function hasHostRoot(node) {
     return false;
 }
 function filterNodesInPlace(idSet, snapshot, cb) {
-    const ids = Array.from(idSet.keys());
+    const ids = Array.from(idSet);
     for (const id of ids) {
         const node = snapshot.getNodeById(id);
         if (node && !cb(node, snapshot)) {
@@ -508,7 +512,7 @@ function filterNodesInPlace(idSet, snapshot, cb) {
     }
 }
 function applyToNodes(idSet, snapshot, cb, options = {}) {
-    let ids = Array.from(idSet.keys());
+    let ids = Array.from(idSet);
     if (options.shuffle) {
         ids.sort(() => Math.random() - 0.5);
     }
@@ -951,6 +955,33 @@ function pathHasEdgeWithIndex(path, idx) {
     }
     return false;
 }
+function pathHasEdgeWithName(path, edgeName) {
+    let p = path;
+    while (p) {
+        if (p.edge && p.edge.name_or_index === edgeName) {
+            return true;
+        }
+        p = p.next;
+    }
+    return false;
+}
+function pathHasNodeOrEdgeWithName(path, name) {
+    if (name == null) {
+        return true;
+    }
+    name = name.toLowerCase();
+    let p = path;
+    while (p) {
+        if (p.edge && `${p.edge.name_or_index}`.toLowerCase().includes(name)) {
+            return true;
+        }
+        if (p.node && `${p.node.name}`.toLowerCase().includes(name)) {
+            return true;
+        }
+        p = p.next;
+    }
+    return false;
+}
 function getLastNodeId(path) {
     if (!path) {
         return -1;
@@ -1694,11 +1725,14 @@ function runShell(command, options = {}) {
         execOptions.shell = '/bin/bash';
     }
     let ret = null;
+    if (Config_1.default.verbose || Config_1.default.isContinuousTest) {
+        Console_1.default.lowLevel(`running shell command: ${command}`);
+    }
     try {
         ret = child_process_1.default.execSync(command, execOptions);
     }
     catch (ex) {
-        if (Config_1.default.verbose) {
+        if (Config_1.default.verbose || Config_1.default.isContinuousTest) {
             if (ex instanceof Error) {
                 Console_1.default.lowLevel(ex.message);
                 Console_1.default.lowLevel((_c = ex.stack) !== null && _c !== void 0 ? _c : '');
@@ -1814,6 +1848,7 @@ exports.default = {
     hasReactEdges,
     isAlternateNode,
     isBlinkRootNode,
+    isCppRootsNode,
     isDOMInternalNode,
     isDOMNodeIncomplete,
     isDOMTextNode,
@@ -1861,6 +1896,8 @@ exports.default = {
     objectToMap,
     pathHasDetachedHTMLNode,
     pathHasEdgeWithIndex,
+    pathHasEdgeWithName,
+    pathHasNodeOrEdgeWithName,
     repeat,
     resolveFilePath,
     resolveSnapshotFilePath,

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

@@ -21,25 +21,34 @@ class HeapStringNode extends HeapNode_1.default {
     }
     get stringValue() {
         var _a, _b, _c;
-        const type = this.type;
-        if (type === 'concatenated string') {
-            const firstNode = (_a = this.getReferenceNode('first')) === null || _a === void 0 ? void 0 : _a.toStringNode();
-            const secondNode = (_b = this.getReferenceNode('second')) === null || _b === void 0 ? void 0 : _b.toStringNode();
-            if (firstNode == null || secondNode == null) {
-                throw (0, HeapUtils_1.throwError)(new Error('broken concatenated string'));
+        const stack = [this];
+        let ret = '';
+        while (stack.length > 0) {
+            const node = stack.pop();
+            const type = node.type;
+            if (type === 'concatenated string') {
+                const firstNode = (_a = node.getReferenceNode('first')) === null || _a === void 0 ? void 0 : _a.toStringNode();
+                const secondNode = (_b = node.getReferenceNode('second')) === null || _b === void 0 ? void 0 : _b.toStringNode();
+                if (firstNode == null || secondNode == null) {
+                    throw (0, HeapUtils_1.throwError)(new Error('broken concatenated string'));
+                }
+                stack.push(secondNode);
+                stack.push(firstNode);
+                continue;
             }
-            return firstNode.stringValue + secondNode.stringValue;
-        }
-        if (type === 'sliced string') {
-            const parentNode = (_c = this.getReferenceNode('parent')) === null || _c === void 0 ? void 0 : _c.toStringNode();
-            if (parentNode == null) {
-                throw (0, HeapUtils_1.throwError)(new Error('broken sliced string'));
+            if (type === 'sliced string') {
+                const parentNode = (_c = node.getReferenceNode('parent')) === null || _c === void 0 ? void 0 : _c.toStringNode();
+                if (parentNode == null) {
+                    throw (0, HeapUtils_1.throwError)(new Error('broken sliced string'));
+                }
+                // sliced string in heap snapshot doesn't include
+                // the start index and the end index, so this may be inaccurate
+                ret += `<sliced string of @${parentNode.id}>`;
+                continue;
             }
-            // sliced string in heap snapshot doesn't include
-            // the start index and the end index, so this may be inaccurate
-            return parentNode.stringValue;
+            ret += node.name;
         }
-        return this.name;
+        return ret;
     }
     getJSONifyableObject() {
         const rep = super.getJSONifyableObject();

package/dist/lib/leak-filters/rules/FilterOverSizedNodeAsLeak.rule.js

@@ -8,8 +8,13 @@
  * @format
  * @oncall web_perf_infra
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterOverSizedNodeAsLeakRule = void 0;
+const Utils_1 = __importDefault(require("../../Utils"));
+const Config_1 = require("../../Config");
 const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
 /**
  * trivial nodes are not reported as memory leaks
@@ -17,6 +22,10 @@ const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
 class FilterOverSizedNodeAsLeakRule {
     filter(config, node) {
         if (config.oversizeObjectAsLeak) {
+            // TODO: add support to skip this check
+            if (!isHeapNodeUsefulForLeakTraceDiffing(config, node)) {
+                return BaseLeakFilter_rule_1.LeakDecision.NOT_LEAK;
+            }
             return node.retainedSize > config.oversizeThreshold
                 ? BaseLeakFilter_rule_1.LeakDecision.LEAK
                 : BaseLeakFilter_rule_1.LeakDecision.NOT_LEAK;
@@ -25,3 +34,44 @@ class FilterOverSizedNodeAsLeakRule {
     }
 }
 exports.FilterOverSizedNodeAsLeakRule = FilterOverSizedNodeAsLeakRule;
+function isHeapNodeUsefulForLeakTraceDiffing(config, node) {
+    if (config.traceAllObjectsMode === Config_1.TraceObjectMode.Default) {
+        return true;
+    }
+    const name = node.name;
+    if (node.type !== 'object') {
+        return false;
+    }
+    if (name.startsWith('system / ')) {
+        return false;
+    }
+    if (Utils_1.default.isFiberNode(node) && !Utils_1.default.isDetachedFiberNode(node)) {
+        return false;
+    }
+    if (Utils_1.default.isDOMNodeIncomplete(node) && !Utils_1.default.isDetachedDOMNode(node)) {
+        return false;
+    }
+    if (node.getAnyReferrer('__proto__') != null) {
+        return false;
+    }
+    if (node.getAnyReferrer('prototype') != null) {
+        return false;
+    }
+    // react internal objects
+    if (node.getAnyReferrer('dependencies') != null) {
+        return false;
+    }
+    if (node.getAnyReferrer('memoizedState') != null) {
+        return false;
+    }
+    if (node.getAnyReferrer('next') != null) {
+        return false;
+    }
+    if (node.getAnyReferrer('deps') != null) {
+        return false;
+    }
+    if (node.getReference('baseQueue') != null) {
+        return false;
+    }
+    return true;
+}

package/dist/lib/trace-filters/TraceFilterRuleList.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Constant_1 = __importDefault(require("../Constant"));
 const InternalValueSetter_1 = require("../InternalValueSetter");
 const FilterAttachedDOMToDetachedDOMTrace_rule_1 = require("./rules/FilterAttachedDOMToDetachedDOMTrace.rule");
+const FilterCppRootsToDetachedDOMTrace_rule_1 = require("./rules/FilterCppRootsToDetachedDOMTrace.rule");
 const FilterDOMNodeChainTrace_rule_1 = require("./rules/FilterDOMNodeChainTrace.rule");
 const FilterHermesTrace_rule_1 = require("./rules/FilterHermesTrace.rule");
 const FilterInternalNodeTrace_rule_1 = require("./rules/FilterInternalNodeTrace.rule");
@@ -29,5 +30,6 @@ const list = [
     new FilterPendingActivitiesTrace_rule_1.FilterPendingActivitiesTraceRule(),
     new FilterDOMNodeChainTrace_rule_1.FilterDOMNodeChainTraceRule(),
     new FilterAttachedDOMToDetachedDOMTrace_rule_1.FilterAttachedDOMToDetachedDOMTraceRule(),
+    new FilterCppRootsToDetachedDOMTrace_rule_1.FilterCppRootsToDetachedDOMTraceRule(),
 ];
 exports.default = (0, InternalValueSetter_1.setInternalValue)(list, __filename, Constant_1.default.internalDir);

package/dist/lib/trace-filters/rules/FilterCppRootsToDetachedDOMTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterCppRootsToDetachedDOMTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterCppRootsToDetachedDOMTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterCppRootsToDetachedDOMTrace.rule.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterCppRootsToDetachedDOMTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterCppRootsToDetachedDOMTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path contains edges from [C++ roots] to detached DOM elements
+        if (curConfig.hideBrowserLeak && hasCppRootsToDetachedDOMNode(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterCppRootsToDetachedDOMTraceRule = FilterCppRootsToDetachedDOMTraceRule;
+function hasCppRootsToDetachedDOMNode(path) {
+    let p = path;
+    // all the reference chain consists of DOM elements/nodes
+    while (p && p.node) {
+        if (Utils_1.default.isCppRootsNode(p.node) &&
+            p.next &&
+            p.next.node &&
+            Utils_1.default.isDOMNodeIncomplete(p.next.node)) {
+            return true;
+        }
+        p = p.next;
+    }
+    return false;
+}

package/dist/paths/TraceFinder.js

@@ -450,7 +450,7 @@ class TraceFinder {
         return Config_1.default.edgeNameGreyList.has(String(edge.name_or_index));
     }
     isLessPreferableNode(node) {
-        return Config_1.default.nodeNameGreyList.has(node.name);
+        return Config_1.default.nodeNameGreyList.has(node.name) || Utils_1.default.isCppRootsNode(node);
     }
     // each edge is indexed by fromNode's ID, toNode's ID, edge name, and edge type
     getEdgeKey(edge) {

package/dist/trace-cluster/TraceBucket.js

@@ -22,6 +22,7 @@ const TraceSimilarityStrategy_1 = __importDefault(require("./strategies/TraceSim
 const TraceAsClusterStrategy_1 = __importDefault(require("./strategies/TraceAsClusterStrategy"));
 const MLTraceSimilarityStrategy_1 = __importDefault(require("./strategies/MLTraceSimilarityStrategy"));
 const ClusterUtils_1 = require("./ClusterUtils");
+const TraceSampler_1 = __importDefault(require("../lib/TraceSampler"));
 // sync up with html/intern/js/webspeed/memlab/lib/LeakCluster.js
 class NormalizedTrace {
     constructor(p = null, snapshot = null) {
@@ -127,26 +128,19 @@ class NormalizedTrace {
         return Math.max(30, Utils_1.default.getNumberAtPercentile(lengthArr, 80));
     }
     static samplePaths(paths) {
-        const maxCount = 5000;
+        const maxCount = Config_1.default.maxSamplesForClustering;
         if (paths.length <= maxCount) {
             return [...paths];
         }
-        const sampleRatio = Math.min(1, maxCount / paths.length);
-        if (sampleRatio < 1) {
-            Console_1.default.warning('Sampling trace due to a large number of traces:');
-            Console_1.default.lowLevel(` Number of Traces: ${paths.length}`);
-            Console_1.default.lowLevel(` Sampling Ratio: ${Utils_1.default.getReadablePercent(sampleRatio)}`);
-        }
+        const sampler = new TraceSampler_1.default(paths.length);
         const ret = [];
         const samplePathMaxLength = NormalizedTrace.getSamplePathMaxLength(paths);
         if (Config_1.default.verbose) {
             Console_1.default.lowLevel(` Sample Trace's Max Length: ${samplePathMaxLength}`);
         }
+        paths = paths.filter(p => Utils_1.default.getLeakTracePathLength(p) <= samplePathMaxLength);
         for (const p of paths) {
-            if (Utils_1.default.getLeakTracePathLength(p) > samplePathMaxLength) {
-                continue;
-            }
-            if (Math.random() < sampleRatio) {
+            if (sampler.sample()) {
                 ret.push(p);
             }
             else {
@@ -157,6 +151,9 @@ class NormalizedTrace {
                 }
             }
         }
+        if (Config_1.default.verbose) {
+            Console_1.default.lowLevel(`Number of samples after sampling: ${ret.length}.`);
+        }
         return ret;
     }
     static diffTraces(newTraces, existingTraces, // existing representative traces
@@ -194,6 +191,11 @@ class NormalizedTrace {
             }
             return traceToClusterMap.get(trace);
         };
+        if (Config_1.default.isContinuousTest) {
+            Console_1.default.lowLevel(`${staleClusters.length} stale clusters`);
+            Console_1.default.lowLevel(`${clustersToAdd.length} new clusters`);
+            Console_1.default.lowLevel(`${allClusters.length} clusters in total`);
+        }
         return {
             staleClusters: staleClusters.map(traceToCluster),
             clustersToAdd: clustersToAdd.map(traceToCluster),

package/package.json

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