@memlab/core 1.1.22 → 1.1.23

package/dist/__tests__/lib/TestUtils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 { IHeapSnapshot } from '../../lib/Types';
+/** @internal */
+export declare function getFullHeapFromFile(file: string): Promise<IHeapSnapshot>;
+//# sourceMappingURL=TestUtils.d.ts.map

package/dist/__tests__/lib/TestUtils.js

@@ -0,0 +1,39 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFullHeapFromFile = void 0;
+const __1 = require("../..");
+/** @internal */
+function getFullHeapFromFile(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield loadProcessedSnapshot({ file });
+    });
+}
+exports.getFullHeapFromFile = getFullHeapFromFile;
+function loadProcessedSnapshot(options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const opt = { buildNodeIdIndex: true, verbose: true };
+        const file = options.file || __1.utils.getSnapshotFilePathWithTabType(/.*/);
+        const snapshot = yield __1.utils.getSnapshotFromFile(file, opt);
+        __1.analysis.preparePathFinder(snapshot);
+        __1.info.flush();
+        return snapshot;
+    });
+}

package/dist/lib/Config.d.ts

@@ -114,7 +114,7 @@ export declare class MemLabConfig {
     qes: QuickExperiment[];
     isOndemand: boolean;
     useExternalSnapshot: boolean;
-    externalRunMetaFile: string;
+    externalRunMetaTemplateFile: string;
     externalSnapshotVisitOrderFile: string;
     externalSnapshotDir: Nullable<string>;
     externalSnapshotFilePaths: string[];

package/dist/lib/Config.js

@@ -321,7 +321,10 @@ class MemLabConfig {
         // node names excluded from the trace finding
         this.nodeNameBlockList = new Set(['system / PropertyCell']);
         // edge names excluded from the trace finding
-        this.edgeNameBlockList = new Set(['feedback_cell']);
+        this.edgeNameBlockList = new Set([
+            'feedback_cell',
+            'part of key -> value pair in ephemeron table',
+        ]);
         // node names less preferable in trace finding
         this.nodeNameGreyList = new Set([
             'InternalNode',

package/dist/lib/FileManager.js

@@ -427,7 +427,7 @@ class FileManager {
         config.heapAnalysisLogDir = joinAndProcessDir(options, this.getHeapAnalysisLogDir(options));
         config.metricsOutDir = joinAndProcessDir(options, loggerOutDir, 'metrics');
         config.reportScreenshotFile = path_1.default.join(outDir, 'report.png');
-        config.externalRunMetaFile = this.getRunMetaExternalTemplateFile();
+        config.externalRunMetaTemplateFile = this.getRunMetaExternalTemplateFile();
         config.externalSnapshotVisitOrderFile =
             this.getSnapshotSequenceExternalTemplateFile();
         joinAndProcessDir(options, this.getUniqueTraceClusterDir(options));

package/dist/lib/HeapAnalyzer.js

@@ -49,13 +49,13 @@ class MemoryAnalyst {
             const controlSnapshotDirs = options.controlWorkDirs.map(controlWorkDir => FileManager_1.default.getCurDataDir({
                 workDir: controlWorkDir,
             }));
-            const treatmentSnapshotDir = FileManager_1.default.getCurDataDir({
-                workDir: options.treatmentWorkDir,
-            });
+            const treatmentSnapshotDirs = options.treatmentWorkDirs.map(treatmentWorkDir => FileManager_1.default.getCurDataDir({
+                workDir: treatmentWorkDir,
+            }));
             // check control working dir
             controlSnapshotDirs.forEach(controlSnapshotDir => Utils_1.default.checkSnapshots({ snapshotDir: controlSnapshotDir }));
             // check treatment working dir
-            Utils_1.default.checkSnapshots({ snapshotDir: treatmentSnapshotDir });
+            treatmentSnapshotDirs.forEach(treatmentSnapshotDir => Utils_1.default.checkSnapshots({ snapshotDir: treatmentSnapshotDir }));
             // display control and treatment memory
             MemoryBarChart_1.default.plotMemoryBarChart(options);
             return this.diffMemoryLeakTraces(options);
@@ -76,17 +76,26 @@ class MemoryAnalyst {
                 leakPathsFromControlRuns.push(this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: controlWorkDir }));
                 controlSnapshots.push(snapshotDiff.snapshot);
             }
-            // diff snapshots and get treatment raw paths
-            const snapshotDiff = yield this.diffSnapshots({
-                loadAllSnapshots: true,
-                workDir: options.treatmentWorkDir,
-            });
-            const treatmentLeakPaths = this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: options.treatmentWorkDir });
-            const treatmentSnapshot = snapshotDiff.snapshot;
+            // diff snapshots from treatment dirs and get treatment raw paths array
+            const treatmentSnapshots = [];
+            const leakPathsFromTreatmentRuns = [];
+            let firstTreatmentSnapshotDiff = null;
+            for (const treatmentWorkDir of options.treatmentWorkDirs) {
+                const snapshotDiff = yield this.diffSnapshots({
+                    loadAllSnapshots: true,
+                    workDir: treatmentWorkDir,
+                });
+                if (firstTreatmentSnapshotDiff == null) {
+                    firstTreatmentSnapshotDiff = snapshotDiff;
+                }
+                leakPathsFromTreatmentRuns.push(this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: treatmentWorkDir }));
+                treatmentSnapshots.push(snapshotDiff.snapshot);
+            }
             const controlPathCounts = JSON.stringify(leakPathsFromControlRuns.map(leakPaths => leakPaths.length));
+            const treatmentPathCounts = JSON.stringify(leakPathsFromTreatmentRuns.map(leakPaths => leakPaths.length));
             Console_1.default.topLevel(`${controlPathCounts} traces from control group`);
-            Console_1.default.topLevel(`${treatmentLeakPaths.length} traces from treatment group`);
-            const result = TraceBucket_1.default.clusterControlTreatmentPaths(leakPathsFromControlRuns, controlSnapshots, treatmentLeakPaths, treatmentSnapshot, Utils_1.default.aggregateDominatorMetrics, {
+            Console_1.default.topLevel(`${treatmentPathCounts} traces from treatment group`);
+            const result = TraceBucket_1.default.clusterControlTreatmentPaths(leakPathsFromControlRuns, controlSnapshots, leakPathsFromTreatmentRuns, treatmentSnapshots, Utils_1.default.aggregateDominatorMetrics, {
                 strategy: Config_1.default.isMLClustering
                     ? new MLTraceSimilarityStrategy_1.default()
                     : undefined,
@@ -95,7 +104,10 @@ class MemoryAnalyst {
             yield this.serializeClusterUpdate(result.treatmentOnlyClusters);
             // serialize JSON file with detailed leak trace information
             const treatmentOnlyPaths = result.treatmentOnlyClusters.map(c => c.path);
-            return LeakTraceDetailsLogger_1.default.logTraces(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, snapshotDiff.listOfLeakedHeapNodeIdSet, treatmentOnlyPaths, Config_1.default.traceJsonOutDir);
+            if (firstTreatmentSnapshotDiff == null) {
+                throw Utils_1.default.haltOrThrow('treatemnt snapshot diff result not found');
+            }
+            return LeakTraceDetailsLogger_1.default.logTraces(firstTreatmentSnapshotDiff.leakedHeapNodeIdSet, firstTreatmentSnapshotDiff.snapshot, firstTreatmentSnapshotDiff.listOfLeakedHeapNodeIdSet, treatmentOnlyPaths, Config_1.default.traceJsonOutDir);
         });
     }
     // find all unique pattern of leaks

package/dist/lib/RunInfoUtils.d.ts

@@ -11,6 +11,7 @@ import type { Nullable, Optional, RunMetaInfo } from './Types';
 export declare class RunMetaInfoManager {
     getRunMetaFilePath(options?: {
         workDir?: Optional<string>;
+        readonly?: Optional<boolean>;
     }): string;
     saveRunMetaInfo(runMetaInfo: RunMetaInfo, options?: {
         workDir?: Optional<string>;

package/dist/lib/RunInfoUtils.js

@@ -16,8 +16,10 @@ class RunMetaInfoManager {
         if ((options === null || options === void 0 ? void 0 : options.workDir) != null) {
             return FileManager_1.default.getRunMetaFile({ workDir: options.workDir });
         }
-        if (Config_1.default.useExternalSnapshot) {
-            return Config_1.default.externalRunMetaFile;
+        if ((options === null || options === void 0 ? void 0 : options.readonly) && Config_1.default.useExternalSnapshot) {
+            // only returns the template file if the
+            // run meta file is used for readonly purpose
+            return Config_1.default.externalRunMetaTemplateFile;
         }
         if (Config_1.default.runMetaFile != null) {
             return Config_1.default.runMetaFile;
@@ -40,7 +42,8 @@ class RunMetaInfoManager {
         return runMetaInfo;
     }
     loadRunMetaInfo(options) {
-        const file = (options === null || options === void 0 ? void 0 : options.metaFile) || this.getRunMetaFilePath(options);
+        const file = (options === null || options === void 0 ? void 0 : options.metaFile) ||
+            this.getRunMetaFilePath(Object.assign({ readonly: true }, options));
         try {
             return this.loadRunMetaInfoFromFile(file);
         }
@@ -49,7 +52,8 @@ class RunMetaInfoManager {
         }
     }
     loadRunMetaInfoSilentFail(options) {
-        const file = (options === null || options === void 0 ? void 0 : options.metaFile) || this.getRunMetaFilePath(options);
+        const file = (options === null || options === void 0 ? void 0 : options.metaFile) ||
+            this.getRunMetaFilePath(Object.assign({ readonly: true }, options));
         try {
             return this.loadRunMetaInfoFromFile(file);
         }

package/dist/lib/SerializationHelper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 { IHeapNode, IHeapSnapshot, ISerializationHelper, ISerializedInfo, JSONifyArgs, JSONifyOptions, Nullable } from './Types';
+export declare class SerializationHelper implements ISerializationHelper {
+    protected snapshot: Nullable<IHeapSnapshot>;
+    setSnapshot(snapshot: IHeapSnapshot): void;
+    createOrMergeWrapper(info: ISerializedInfo, _node: IHeapNode, _args: JSONifyArgs, _options: JSONifyOptions): ISerializedInfo;
+}
+declare const _default: typeof SerializationHelper;
+export default _default;
+//# sourceMappingURL=SerializationHelper.d.ts.map

package/dist/lib/SerializationHelper.js

@@ -0,0 +1,36 @@
+"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.SerializationHelper = void 0;
+const InternalValueSetter_1 = require("./InternalValueSetter");
+const Constant_1 = __importDefault(require("./Constant"));
+class SerializationHelper {
+    constructor() {
+        this.snapshot = null;
+    }
+    setSnapshot(snapshot) {
+        this.snapshot = snapshot;
+    }
+    createOrMergeWrapper(info, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _node, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _args, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _options) {
+        return info;
+    }
+}
+exports.SerializationHelper = SerializationHelper;
+exports.default = (0, InternalValueSetter_1.setInternalValue)(SerializationHelper, __filename, Constant_1.default.internalDir);

package/dist/lib/Serializer.d.ts

@@ -7,12 +7,8 @@
  * @format
  * @oncall web_perf_infra
  */
-import { E2EStepInfo, HeapNodeIdSet, IHeapEdge, IHeapNode, IHeapSnapshot, ISerializedInfo, LeakTracePathItem, Nullable } from './Types';
-declare type JSONifyArgs = {
-    leakedIdSet?: Set<number>;
-    nodeIdsInSnapshots?: Array<Set<number>>;
-};
-declare function JSONifyPath(path: LeakTracePathItem, _snapshot: IHeapSnapshot, args: JSONifyArgs): Nullable<ISerializedInfo>;
+import { E2EStepInfo, HeapNodeIdSet, IHeapEdge, IHeapNode, IHeapSnapshot, ISerializedInfo, JSONifyArgs, LeakTracePathItem, Nullable } from './Types';
+declare function JSONifyPath(path: LeakTracePathItem, snapshot: IHeapSnapshot, args: JSONifyArgs): Nullable<ISerializedInfo>;
 declare type SummarizeOptions = {
     compact?: boolean;
     color?: boolean;

package/dist/lib/Serializer.js

@@ -18,6 +18,7 @@ const Config_1 = __importDefault(require("./Config"));
 const Utils_1 = __importDefault(require("./Utils"));
 const Console_1 = __importDefault(require("./Console"));
 const TraceFinder_1 = __importDefault(require("../paths/TraceFinder"));
+const SerializationHelper_1 = __importDefault(require("./SerializationHelper"));
 const REGEXP_NAME_CLEANUP = /[[]\(\)]/g;
 const EMPTY_JSONIFY_OPTIONS = {
     fiberNodeReturnTrace: {},
@@ -374,7 +375,12 @@ function JSONifyNode(node, args, options) {
     if (node.dominatorNode) {
         info['dominator id (extra)'] = `@${node.dominatorNode.id}`;
     }
-    return info;
+    // use serialization helper to wrap around
+    // the JSON node with additional tagging information
+    const { serializationHelper } = options;
+    return serializationHelper
+        ? serializationHelper.createOrMergeWrapper(info, node, args, options)
+        : info;
 }
 function JSONifyTabsOrder() {
     const file = Utils_1.default.getSnapshotSequenceFilePath();
@@ -383,7 +389,7 @@ function JSONifyTabsOrder() {
 function shouldHighlight(node) {
     return Utils_1.default.isDetachedDOMNode(node) || Utils_1.default.isDetachedFiberNode(node);
 }
-function JSONifyPath(path, _snapshot, args) {
+function JSONifyPath(path, snapshot, args) {
     if (!path.node) {
         return null;
     }
@@ -393,6 +399,9 @@ function JSONifyPath(path, _snapshot, args) {
     ret['$tabsOrder:' + JSONifyTabsOrder()] = '';
     ret[`${idx++}: ${getNodeNameInJSON(path.node, args)}`] = JSONifyNode(path.node, args, Object.assign(Object.assign({}, EMPTY_JSONIFY_OPTIONS), { processedNodeId: new Set() }));
     let pathItem = path;
+    // initialize serialization helper
+    const serializationHelper = new SerializationHelper_1.default();
+    serializationHelper.setSnapshot(snapshot);
     while (pathItem === null || pathItem === void 0 ? void 0 : pathItem.edge) {
         const edge = pathItem.edge;
         const nextNode = edge.toNode;
@@ -401,7 +410,7 @@ function JSONifyPath(path, _snapshot, args) {
             nextNode.highlight = true;
         }
         const edgeRetainSize = pathItem.edgeRetainSize;
-        ret[`${idx++}: ${getEdgeNameInJSON(edge, edgeRetainSize)}${getNodeNameInJSON(nextNode, args)}`] = JSONifyNode(nextNode, args, Object.assign(Object.assign({}, EMPTY_JSONIFY_OPTIONS), { processedNodeId: new Set() }));
+        ret[`${idx++}: ${getEdgeNameInJSON(edge, edgeRetainSize)}${getNodeNameInJSON(nextNode, args)}`] = JSONifyNode(nextNode, args, Object.assign(Object.assign({}, EMPTY_JSONIFY_OPTIONS), { processedNodeId: new Set(), serializationHelper }));
         pathItem = pathItem.next;
     }
     return ret;

package/dist/lib/Types.d.ts

@@ -806,8 +806,9 @@ export declare type TraceClusterMetaInfo = {
 };
 /** @internal */
 export declare type ControlTreatmentClusterResult = {
-    controlOnlyClusters: TraceCluster[];
+    controlLikelyOrOnlyClusters: TraceCluster[];
     treatmentOnlyClusters: TraceCluster[];
+    treatmentLikelyClusters: TraceCluster[];
     hybridClusters: Array<{
         control: TraceCluster;
         treatment: TraceCluster;
@@ -1930,12 +1931,12 @@ export interface IOveralLeakInfo extends Partial<IOveralHeapInfo> {
 /** @internal */
 export declare type DiffLeakOptions = {
     controlWorkDirs: string[];
-    treatmentWorkDir: string;
+    treatmentWorkDirs: string[];
 };
 /** @internal */
 export declare type PlotMemoryOptions = {
     controlWorkDirs?: string[];
-    treatmentWorkDir?: string;
+    treatmentWorkDirs?: string[];
     workDir?: string;
 } & IMemoryAnalystOptions;
 /** @internal */
@@ -1976,4 +1977,21 @@ export declare type CommandOptionExample = string | {
     description?: string;
     cliOptionExample: string;
 };
+/** @internal */
+export declare type JSONifyArgs = {
+    leakedIdSet?: Set<number>;
+    nodeIdsInSnapshots?: Array<Set<number>>;
+};
+/** @internal */
+export interface ISerializationHelper {
+    setSnapshot(snapshot: IHeapSnapshot): void;
+    createOrMergeWrapper(info: ISerializedInfo, node: IHeapNode, args: JSONifyArgs, options: JSONifyOptions): ISerializedInfo;
+}
+/** @internal */
+export declare type JSONifyOptions = {
+    fiberNodeReturnTrace: Record<number, string>;
+    processedNodeId: Set<number>;
+    forceJSONifyDepth?: number;
+    serializationHelper?: ISerializationHelper;
+};
 //# sourceMappingURL=Types.d.ts.map

package/dist/lib/Utils.d.ts

@@ -49,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;
@@ -229,6 +230,7 @@ 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;

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) {
@@ -497,6 +497,35 @@ 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();
     }
@@ -1533,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) {
@@ -1891,6 +1921,7 @@ exports.default = {
     mapToObject,
     markAllDetachedFiberNode,
     markAlternateFiberNode,
+    markDetachedFiberNode,
     memCache,
     normalizeBaseUrl,
     objectToMap,

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/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/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/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[];

package/dist/trace-cluster/TraceBucket.js

@@ -310,43 +310,64 @@ class NormalizedTrace {
             leakedNodeIds: new Set(),
         };
     }
-    static clusterControlTreatmentPaths(leakPathsFromControlRuns, controlSnapshots, treatmentPaths, treatmentSnapshot, aggregateDominatorMetrics, option = {}) {
+    static clusterControlTreatmentPaths(leakPathsFromControlRuns, controlSnapshots, leakPathsFromTreatmentRuns, treatmentSnapshots, aggregateDominatorMetrics, option = {}) {
         const result = {
-            controlOnlyClusters: [],
+            controlLikelyOrOnlyClusters: [],
             treatmentOnlyClusters: [],
+            treatmentLikelyClusters: [],
             hybridClusters: [],
         };
         Console_1.default.overwrite('Clustering leak traces');
         const totalControlPaths = leakPathsFromControlRuns.reduce((count, leakPaths) => count + leakPaths.length, 0);
-        if (totalControlPaths === 0 && treatmentPaths.length === 0) {
+        const totalTreatmentPaths = leakPathsFromTreatmentRuns.reduce((count, leakPaths) => count + leakPaths.length, 0);
+        if (totalControlPaths === 0 && totalTreatmentPaths === 0) {
             Console_1.default.midLevel('No leaks found');
             return result;
         }
         // sample paths if there are too many
         const flattenedLeakPathsFromControlRuns = leakPathsFromControlRuns.reduce((arr, leakPaths) => [...arr, ...leakPaths], []);
         const controlPaths = this.samplePaths(flattenedLeakPathsFromControlRuns);
-        treatmentPaths = this.samplePaths(treatmentPaths);
+        const pathsForEachTreatmentGroup = leakPathsFromTreatmentRuns.map((treatmentPaths) => this.samplePaths(treatmentPaths));
         // build control trace to control path map
         const controlTraceToPathMap = NormalizedTrace.buildTraceToPathMap(controlPaths);
         const controlTraces = Array.from(controlTraceToPathMap.keys());
-        // build treatment trace to treatment path map
-        const treatmentTraceToPathMap = NormalizedTrace.buildTraceToPathMap(treatmentPaths);
-        const treatmentTraces = Array.from(treatmentTraceToPathMap.keys());
+        // build treatment trace to treatment path maps
+        // we need to know the mapping to each treatment group
+        // to figure out if a trace cluster contains traces from all treatment groups
+        const treatmentTraceToPathMaps = pathsForEachTreatmentGroup.map(treatmentPaths => NormalizedTrace.buildTraceToPathMap(treatmentPaths));
+        const treatmentTraceToPathMap = new Map();
+        const treatmentTraces = [];
+        for (const map of treatmentTraceToPathMaps) {
+            for (const [key, value] of map.entries()) {
+                treatmentTraceToPathMap.set(key, value);
+                treatmentTraces.push(key);
+            }
+        }
         // 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
+        // pick one of the control and treatment heap snapshots
         const controlSnapshot = controlSnapshots[0];
+        const treatmentSnapshot = treatmentSnapshots[0];
         // construct TraceCluster from clustering result
         allClusters.forEach((traces) => {
             var _a, _b;
             const controlCluster = NormalizedTrace.initEmptyCluster(controlSnapshot);
             const treatmentCluster = NormalizedTrace.initEmptyCluster(treatmentSnapshot);
+            // a set containing each the treatment group that
+            // has at least one trace in this cluster
+            const treatmentSetWithClusterTrace = new Set();
             for (const trace of traces) {
                 const normalizedTrace = trace;
                 if (controlTraceToPathMap.has(normalizedTrace)) {
                     NormalizedTrace.pushLeakPathToCluster(controlTraceToPathMap, normalizedTrace, controlCluster);
                 }
                 else {
+                    for (let i = 0; i < treatmentTraceToPathMaps.length; ++i) {
+                        if (treatmentTraceToPathMaps[i].has(normalizedTrace)) {
+                            treatmentSetWithClusterTrace.add(i);
+                            break;
+                        }
+                    }
                     NormalizedTrace.pushLeakPathToCluster(treatmentTraceToPathMap, normalizedTrace, treatmentCluster);
                 }
             }
@@ -360,11 +381,19 @@ class NormalizedTrace {
             if (treatmentClusterSize > 0) {
                 this.calculateClusterRetainedSize(treatmentCluster, treatmentSnapshot, aggregateDominatorMetrics);
             }
-            if (controlClusterSize === 0) {
+            if (controlClusterSize === 0 &&
+                treatmentSetWithClusterTrace.size === leakPathsFromTreatmentRuns.length) {
+                // only when the leak cluster consists of traces from all treatment groups
                 result.treatmentOnlyClusters.push(treatmentCluster);
             }
+            else if (controlClusterSize === 0) {
+                // when the leak cluster consists of traces from
+                // some but not all of treatment groups
+                result.treatmentLikelyClusters.push(treatmentCluster);
+            }
             else if (treatmentClusterSize === 0) {
-                result.controlOnlyClusters.push(controlCluster);
+                // when the leak cluster consists of traces from any of the control groups
+                result.controlLikelyOrOnlyClusters.push(controlCluster);
             }
             else {
                 result.hybridClusters.push({
@@ -374,7 +403,8 @@ class NormalizedTrace {
             }
         });
         result.treatmentOnlyClusters.sort((c1, c2) => { var _a, _b; return ((_a = c2.retainedSize) !== null && _a !== void 0 ? _a : 0) - ((_b = c1.retainedSize) !== null && _b !== void 0 ? _b : 0); });
-        result.controlOnlyClusters.sort((c1, c2) => { var _a, _b; return ((_a = c2.retainedSize) !== null && _a !== void 0 ? _a : 0) - ((_b = c1.retainedSize) !== null && _b !== void 0 ? _b : 0); });
+        result.treatmentLikelyClusters.sort((c1, c2) => { var _a, _b; return ((_a = c2.retainedSize) !== null && _a !== void 0 ? _a : 0) - ((_b = c1.retainedSize) !== null && _b !== void 0 ? _b : 0); });
+        result.controlLikelyOrOnlyClusters.sort((c1, c2) => { var _a, _b; return ((_a = c2.retainedSize) !== null && _a !== void 0 ? _a : 0) - ((_b = c1.retainedSize) !== null && _b !== void 0 ? _b : 0); });
         result.hybridClusters.sort((g1, g2) => {
             var _a, _b, _c, _d;
             return ((_a = g2.control.retainedSize) !== null && _a !== void 0 ? _a : 0) +

package/package.json

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