@memlab/core 1.1.20 → 1.1.22

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

@@ -0,0 +1,62 @@
+"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.FilterPendingActivitiesTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterPendingActivitiesTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path has pattern: Pending activitiies -> DetachedElement
+        if (curConfig.hideBrowserLeak &&
+            pendingActivitiesRetainsDetachedElementChain(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterPendingActivitiesTraceRule = FilterPendingActivitiesTraceRule;
+function pendingActivitiesRetainsDetachedElementChain(path) {
+    let p = path;
+    // find the Pending activities
+    while (p && p.node && !Utils_1.default.isPendingActivityNode(p.node)) {
+        p = p.next;
+        if (!p) {
+            return false;
+        }
+    }
+    p = p.next;
+    if (!p || !p.node) {
+        return false;
+    }
+    // Scan the rest of the trace, if the following check is met,
+    // the leak trace is considered as not suitable for debugging:
+    // If the scanner encounters an object o on the
+    // rest of the leak trace, where o is neither a detached DOM node nor a
+    // Fiber Node and if the scanner didn't hit a detached DOM node first
+    while (p && p.node) {
+        if (Utils_1.default.isDetachedDOMNode(p.node)) {
+            return true;
+        }
+        if (!Utils_1.default.isDOMInternalNode(p.node) &&
+            !Utils_1.default.isDetachedDOMNode(p.node) &&
+            !Utils_1.default.isFiberNode(p.node)) {
+            return false;
+        }
+        p = p.next;
+    }
+    return true;
+}

package/dist/lib/trace-filters/rules/FilterShadowRootTrace.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 FilterShadowRootTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterShadowRootTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterShadowRootTrace.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.FilterShadowRootTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterShadowRootTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path has pattern: ShadowRoot -> DetachedElement
+        if (curConfig.hideBrowserLeak && shadowRootRetainsDetachedElement(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterShadowRootTraceRule = FilterShadowRootTraceRule;
+// check if the path has pattern: ShadowRoot -> DetachedElement
+function shadowRootRetainsDetachedElement(path) {
+    let p = path;
+    // find the ShadowRoot
+    while (p && p.node && p.node.name !== 'ShadowRoot') {
+        p = p.next;
+        if (!p) {
+            return false;
+        }
+    }
+    p = p.next;
+    // check if the node is a detached element
+    return !!p && Utils_1.default.isDetachedDOMNode(p.node);
+}

package/dist/lib/trace-filters/rules/FilterStyleEngineTrace.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 FilterStyleEngineTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterStyleEngineTrace.rule.d.ts.map

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

@@ -0,0 +1,49 @@
+"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.FilterStyleEngineTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterStyleEngineTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path has pattern: StyleEngine -> InternalNode -> DetachedElement
+        if (curConfig.hideBrowserLeak && styleEngineRetainsDetachedElement(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterStyleEngineTraceRule = FilterStyleEngineTraceRule;
+// check if the path has pattern: StyleEngine -> InternalNode -> DetachedElement
+function styleEngineRetainsDetachedElement(path) {
+    let p = path;
+    // find the StyleEngine
+    while (p && p.node && p.node.name !== 'StyleEngine') {
+        p = p.next;
+        if (!p) {
+            return false;
+        }
+    }
+    p = p.next;
+    // StyleEngine is not poining to InternalNode
+    if (!p || !p.node || p.node.name !== 'InternalNode') {
+        return false;
+    }
+    p = p.next;
+    // check if the InternalNode is pointing to a detached element
+    return !!p && Utils_1.default.isDetachedDOMNode(p.node);
+}

package/dist/logger/LeakClusterLogger.js

@@ -187,6 +187,7 @@ class LeakClusterLogger {
             leak_trace_summary: trace.getTraceSummary(),
             interaction_vector: interactionVector,
             meta_data: JSON.stringify({
+                extraRunInfo: Utils_1.default.mapToObject(Config_1.default.extraRunInfoMap),
                 browser_info: BrowserInfo_1.default,
                 visit_plan: tabsOrder,
                 trace_record: TraceBucket_1.default.pathToTrace(cluster.path),

package/dist/paths/TraceFinder.js

@@ -428,15 +428,29 @@ class TraceFinder {
         return false;
     }
     isLessPreferableEdge(edge) {
+        const fromNode = edge.fromNode;
+        const toNode = edge.toNode;
         // pending activities -> DOM element is less preferrable
-        if (Utils_1.default.isPendingActivityNode(edge.fromNode) &&
-            Utils_1.default.isDOMNodeIncomplete(edge.toNode)) {
+        if (Utils_1.default.isPendingActivityNode(fromNode) &&
+            Utils_1.default.isDOMNodeIncomplete(toNode)) {
+            return true;
+        }
+        // detached DOM node -> non-detached DOM node is less preferable
+        if (Utils_1.default.isDetachedDOMNode(fromNode) &&
+            Utils_1.default.isDOMNodeIncomplete(toNode) &&
+            !Utils_1.default.isDetachedDOMNode(toNode)) {
+            return true;
+        }
+        // non-detached DOM node -> detached DOM node is less preferable
+        if (Utils_1.default.isDOMNodeIncomplete(fromNode) &&
+            !Utils_1.default.isDetachedDOMNode(fromNode) &&
+            Utils_1.default.isDetachedDOMNode(toNode)) {
             return true;
         }
         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.d.ts

@@ -37,7 +37,7 @@ export default class NormalizedTrace {
     private static buildTraceToPathMap;
     private static pushLeakPathToCluster;
     private static initEmptyCluster;
-    static clusterControlTreatmentPaths(controlPaths: LeakTracePathItem[], controlSnapshot: IHeapSnapshot, treatmentPaths: LeakTracePathItem[], treatmentSnapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb, option?: {
+    static clusterControlTreatmentPaths(leakPathsFromControlRuns: LeakTracePathItem[][], controlSnapshots: IHeapSnapshot[], treatmentPaths: LeakTracePathItem[], treatmentSnapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb, option?: {
         strategy?: IClusterStrategy;
     }): ControlTreatmentClusterResult;
     static generateUnClassifiedClusters(paths: LeakTracePathItem[], snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb): TraceCluster[];

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),
@@ -308,19 +310,21 @@ class NormalizedTrace {
             leakedNodeIds: new Set(),
         };
     }
-    static clusterControlTreatmentPaths(controlPaths, controlSnapshot, treatmentPaths, treatmentSnapshot, aggregateDominatorMetrics, option = {}) {
+    static clusterControlTreatmentPaths(leakPathsFromControlRuns, controlSnapshots, treatmentPaths, treatmentSnapshot, aggregateDominatorMetrics, option = {}) {
         const result = {
             controlOnlyClusters: [],
             treatmentOnlyClusters: [],
             hybridClusters: [],
         };
         Console_1.default.overwrite('Clustering leak traces');
-        if (controlPaths.length === 0 && treatmentPaths.length === 0) {
+        const totalControlPaths = leakPathsFromControlRuns.reduce((count, leakPaths) => count + leakPaths.length, 0);
+        if (totalControlPaths === 0 && treatmentPaths.length === 0) {
             Console_1.default.midLevel('No leaks found');
             return result;
         }
         // sample paths if there are too many
-        controlPaths = this.samplePaths(controlPaths);
+        const flattenedLeakPathsFromControlRuns = leakPathsFromControlRuns.reduce((arr, leakPaths) => [...arr, ...leakPaths], []);
+        const controlPaths = this.samplePaths(flattenedLeakPathsFromControlRuns);
         treatmentPaths = this.samplePaths(treatmentPaths);
         // build control trace to control path map
         const controlTraceToPathMap = NormalizedTrace.buildTraceToPathMap(controlPaths);
@@ -330,6 +334,8 @@ class NormalizedTrace {
         const treatmentTraces = Array.from(treatmentTraceToPathMap.keys());
         // cluster traces from both the control group and the treatment group
         const { allClusters } = NormalizedTrace.diffTraces([...controlTraces, ...treatmentTraces], [], option);
+        // pick one of the control heap snapshots
+        const controlSnapshot = controlSnapshots[0];
         // construct TraceCluster from clustering result
         allClusters.forEach((traces) => {
             var _a, _b;

package/dist/trace-cluster/strategies/TraceSimilarityStrategy.js

@@ -60,6 +60,7 @@ class TraceSimilarityStrategy {
             clustersToAdd.push(traceToCheck);
             clusters.push([traceToCheck]);
         }
+        Console_1.default.overwrite('');
         return { staleClusters, clustersToAdd, allClusters: clusters };
     }
     static isSimilarTrace(t1, t2) {

package/package.json

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