@memlab/core 1.1.21 → 1.1.23

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;
@@ -48,6 +49,7 @@ declare function isAlternateNode(node: IHeapNode): boolean;
 declare function setIsRegularFiberNode(node: IHeapNode): void;
 declare function isRegularFiberNode(node: IHeapNode): boolean;
 declare function hasHostRoot(node: IHeapNode): boolean;
+declare function markDetachedFiberNode(node: IHeapNode): boolean;
 declare type IterateNodeCallback = (node: IHeapNode, snapshot: IHeapSnapshot) => boolean;
 declare function filterNodesInPlace(idSet: Set<number>, snapshot: IHeapSnapshot, cb: IterateNodeCallback): void;
 declare function applyToNodes(idSet: Set<number>, snapshot: IHeapSnapshot, cb: (node: IHeapNode, snapshot: IHeapSnapshot) => void, options?: AnyOptions): void;
@@ -75,6 +77,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 +187,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;
@@ -225,11 +230,14 @@ declare const _default: {
     mapToObject: typeof mapToObject;
     markAllDetachedFiberNode: typeof markAllDetachedFiberNode;
     markAlternateFiberNode: typeof markAlternateFiberNode;
+    markDetachedFiberNode: typeof markDetachedFiberNode;
     memCache: Record<string, any>;
     normalizeBaseUrl: typeof normalizeBaseUrl;
     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

@@ -126,7 +126,7 @@ function isFiberNode(node) {
     return name === 'FiberNode' || name === 'Detached FiberNode';
 }
 // quickly check the detachedness field
-// need to call hasHostRoot(node) before this function
+// need to call markDetachedFiberNode(node) before this function
 // does not traverse and check the existance of HostRoot
 // NOTE: Doesn't work for FiberNode without detachedness field
 function isDetachedFiberNode(node) {
@@ -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;
@@ -493,13 +497,42 @@ function hasHostRoot(node) {
         }
         cur = getReactFiberNode(cur, 'return');
     }
+    return false;
+}
+// The Fiber tree starts with a special type of Fiber node (HostRoot).
+// return true if the node is a mounted Fiber node
+function markDetachedFiberNode(node) {
+    if (node && node.is_detached) {
+        return false;
+    }
+    let cur = node;
+    const visitedIds = new Set();
+    const visitedNodes = new Set();
+    while (cur && isFiberNode(cur)) {
+        if (cur.id == null || visitedIds.has(cur.id)) {
+            break;
+        }
+        visitedNodes.add(cur);
+        // if a Fiber node whose dominator is neither root nor
+        // another Fiber node, then consider it as detached Fiber node
+        if (cur.dominatorNode && cur.dominatorNode.id !== 1) {
+            if (!isFiberNode(cur.dominatorNode)) {
+                cur.markAsDetached();
+            }
+        }
+        visitedIds.add(cur.id);
+        if (isHostRoot(cur)) {
+            return true;
+        }
+        cur = getReactFiberNode(cur, 'return');
+    }
     for (const visitedNode of visitedNodes) {
         visitedNode.markAsDetached();
     }
     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 +541,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 +984,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;
@@ -1502,8 +1562,9 @@ function dumpSnapshot(file, snapshot) {
 function markAllDetachedFiberNode(snapshot) {
     Console_1.default.overwrite('marking all detached Fiber nodes...');
     snapshot.nodes.forEach(node => {
-        // hasHostRoot checks and marks detached Fiber Nodes
-        isFiberNode(node) && !hasHostRoot(node);
+        if (isFiberNode(node)) {
+            markDetachedFiberNode(node);
+        }
     });
 }
 function markAlternateFiberNode(snapshot) {
@@ -1694,11 +1755,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 +1878,7 @@ exports.default = {
     hasReactEdges,
     isAlternateNode,
     isBlinkRootNode,
+    isCppRootsNode,
     isDOMInternalNode,
     isDOMNodeIncomplete,
     isDOMTextNode,
@@ -1856,11 +1921,14 @@ exports.default = {
     mapToObject,
     markAllDetachedFiberNode,
     markAlternateFiberNode,
+    markDetachedFiberNode,
     memCache,
     normalizeBaseUrl,
     objectToMap,
     pathHasDetachedHTMLNode,
     pathHasEdgeWithIndex,
+    pathHasEdgeWithName,
+    pathHasNodeOrEdgeWithName,
     repeat,
     resolveFilePath,
     resolveSnapshotFilePath,

package/dist/lib/charts/MemoryBarChart.js

@@ -97,7 +97,7 @@ class MemoryBarChart {
     }
     loadPlotData(options = {}) {
         // plot data for a single run
-        if (!options.controlWorkDirs && !options.treatmentWorkDir) {
+        if (!options.controlWorkDirs && !options.treatmentWorkDirs) {
             return this.loadPlotDataFromWorkDir(options);
         }
         // plot data for control and test run
@@ -105,7 +105,7 @@ class MemoryBarChart {
             workDir: options.controlWorkDirs && options.controlWorkDirs[0],
         });
         const testPlotData = this.loadPlotDataFromWorkDir({
-            workDir: options.treatmentWorkDir,
+            workDir: options.treatmentWorkDirs && options.treatmentWorkDirs[0],
         });
         // merge plot data
         return this.mergePlotData([controlPlotData, testPlotData]);

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/LeakFilterRuleList.js

@@ -21,6 +21,7 @@ const FilterOverSizedNodeAsLeak_rule_1 = require("./rules/FilterOverSizedNodeAsL
 const FilterStackTraceFrame_rule_1 = require("./rules/FilterStackTraceFrame.rule");
 const FilterTrivialNode_rule_1 = require("./rules/FilterTrivialNode.rule");
 const FilterUnmountedFiberNode_rule_1 = require("./rules/FilterUnmountedFiberNode.rule");
+const FilterXMLHTTPRequest_rule_1 = require("./rules/FilterXMLHTTPRequest.rule");
 const list = [
     new FilterByExternalFilter_rule_1.FilterByExternalFilterRule(),
     new FilterTrivialNode_rule_1.FilterTrivialNodeRule(),
@@ -29,5 +30,6 @@ const list = [
     new FilterUnmountedFiberNode_rule_1.FilterUnmountedFiberNodeRule(),
     new FilterDetachedDOMElement_rule_1.FilterDetachedDOMElementRule(),
     new FilterStackTraceFrame_rule_1.FilterStackTraceFrameRule(),
+    new FilterXMLHTTPRequest_rule_1.FilterXMLHTTPRequestRule(),
 ];
 exports.default = (0, InternalValueSetter_1.setInternalValue)(list, __filename, Constant_1.default.internalDir);

package/dist/lib/leak-filters/rules/FilterDetachedDOMElement.rule.d.ts

@@ -15,6 +15,5 @@ import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
  */
 export declare class FilterDetachedDOMElementRule implements ILeakObjectFilterRule {
     filter(_config: MemLabConfig, node: IHeapNode): LeakDecision;
-    protected checkDetachedFiberNode(config: MemLabConfig, node: IHeapNode): boolean;
 }
 //# sourceMappingURL=FilterDetachedDOMElement.rule.d.ts.map

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

@@ -23,18 +23,31 @@ class FilterDetachedDOMElementRule {
         const isDetached = Utils_1.default.isDetachedDOMNode(node, {
             ignoreInternalNode: true,
         });
-        if (isDetached) {
+        if (isDetached &&
+            !isDominatedByEdgeName(node, 'stateNode') &&
+            !isDetachedDOMNodeDominatedByDehydratedMemoizedState(node)) {
             return BaseLeakFilter_rule_1.LeakDecision.LEAK;
         }
         return BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
     }
-    checkDetachedFiberNode(config, node) {
-        if (!config.detectFiberNodeLeak ||
-            !Utils_1.default.isFiberNode(node) ||
-            Utils_1.default.hasHostRoot(node)) {
-            return false;
-        }
-        return !Utils_1.default.isNodeDominatedByDeletionsArray(node);
-    }
 }
 exports.FilterDetachedDOMElementRule = FilterDetachedDOMElementRule;
+function isDominatedByEdgeName(node, edgeNameOrIndex) {
+    var _a;
+    const referrerNode = node.getAnyReferrerNode(edgeNameOrIndex);
+    if (referrerNode == null) {
+        return false;
+    }
+    return referrerNode.id === ((_a = node.dominatorNode) === null || _a === void 0 ? void 0 : _a.id);
+}
+// check if the input is a detached DOM node dominated by a 'dehydrated'
+// edge from a memoizedState. In this case, the node is not a memory leak
+function isDetachedDOMNodeDominatedByDehydratedMemoizedState(node) {
+    var _a;
+    const referrerNode = node.getAnyReferrerNode('dehydrated', 'property');
+    if (referrerNode == null) {
+        return false;
+    }
+    return (referrerNode.id === ((_a = node.dominatorNode) === null || _a === void 0 ? void 0 : _a.id) &&
+        isDominatedByEdgeName(referrerNode, 'memoizedState'));
+}

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/leak-filters/rules/FilterUnmountedFiberNode.rule.js

@@ -26,9 +26,10 @@ class FilterUnmountedFiberNodeRule {
         return BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
     }
     checkDetachedFiberNode(config, node) {
-        if (!config.detectFiberNodeLeak ||
-            !Utils_1.default.isFiberNode(node) ||
-            Utils_1.default.hasHostRoot(node)) {
+        if (!config.detectFiberNodeLeak || !Utils_1.default.isFiberNode(node)) {
+            return false;
+        }
+        if (!Utils_1.default.isDetachedFiberNode(node)) {
             return false;
         }
         return !Utils_1.default.isNodeDominatedByDeletionsArray(node);

package/dist/lib/leak-filters/rules/FilterXMLHTTPRequest.rule.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { MemLabConfig } from '../../Config';
+import type { IHeapNode } from '../../Types';
+import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
+/**
+ * mark XMLHTTPRequest with status ok as memory leaks
+ */
+export declare class FilterXMLHTTPRequestRule implements ILeakObjectFilterRule {
+    filter(_config: MemLabConfig, node: IHeapNode): LeakDecision;
+    protected checkFinishedXMLHTTPRequest(node: IHeapNode): boolean;
+}
+//# sourceMappingURL=FilterXMLHTTPRequest.rule.d.ts.map

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

@@ -0,0 +1,30 @@
+"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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterXMLHTTPRequestRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+/**
+ * mark XMLHTTPRequest with status ok as memory leaks
+ */
+class FilterXMLHTTPRequestRule {
+    filter(_config, node) {
+        return this.checkFinishedXMLHTTPRequest(node)
+            ? BaseLeakFilter_rule_1.LeakDecision.LEAK
+            : BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+    checkFinishedXMLHTTPRequest(node) {
+        if (node.name !== 'XMLHttpRequest' || node.type !== 'native') {
+            return false;
+        }
+        return (node.findAnyReference((edge) => edge.toNode.name === '{"status":"ok"}') != null);
+    }
+}
+exports.FilterXMLHTTPRequestRule = FilterXMLHTTPRequestRule;

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.d.ts

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