@memlab/core 1.1.20 → 1.1.21

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

@@ -0,0 +1,41 @@
+"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.FilterDOMNodeChainTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterDOMNodeChainTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path consists of only DOM native nodes/elements
+        if (curConfig.hideBrowserLeak && isDOMNodeChain(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterDOMNodeChainTraceRule = FilterDOMNodeChainTraceRule;
+function isDOMNodeChain(path) {
+    let p = path;
+    // all the reference chain consists of DOM elements/nodes
+    while (p && p.node) {
+        if (!Utils_1.default.isRootNode(p.node) && !Utils_1.default.isDOMNodeIncomplete(p.node)) {
+            return false;
+        }
+        p = p.next;
+    }
+    return true;
+}

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

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

@@ -0,0 +1,29 @@
+"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.FilterHermesTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterHermesTraceRule {
+    filter(_p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // do not filter out paths when analyzing Hermes snapshots
+        if (curConfig.jsEngine === 'hermes') {
+            return BaseTraceFilter_rule_1.TraceDecision.INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterHermesTraceRule = FilterHermesTraceRule;

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

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

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

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

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,9 +428,23 @@ 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));

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

@@ -308,19 +308,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 +332,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.21",
   "license": "MIT",
   "description": "memlab core libraries",
   "author": "Liang Gong <lgong@fb.com>",