@memlab/core 1.1.18 → 1.1.20

package/dist/lib/HeapAnalyzer.js

@@ -22,77 +22,83 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
-const babar_1 = __importDefault(require("babar"));
-const LeakClusterLogger_1 = __importDefault(require("../logger/LeakClusterLogger"));
-const LeakTraceDetailsLogger_1 = __importDefault(require("../logger/LeakTraceDetailsLogger"));
-const TraceFinder_1 = __importDefault(require("../paths/TraceFinder"));
-const TraceBucket_1 = __importDefault(require("../trace-cluster/TraceBucket"));
 const Config_1 = __importDefault(require("./Config"));
 const Console_1 = __importDefault(require("./Console"));
 const Serializer_1 = __importDefault(require("./Serializer"));
 const Utils_1 = __importDefault(require("./Utils"));
+const FileManager_1 = __importDefault(require("./FileManager"));
+const MemoryBarChart_1 = __importDefault(require("./charts/MemoryBarChart"));
+const LeakClusterLogger_1 = __importDefault(require("../logger/LeakClusterLogger"));
+const LeakTraceDetailsLogger_1 = __importDefault(require("../logger/LeakTraceDetailsLogger"));
+const TraceFinder_1 = __importDefault(require("../paths/TraceFinder"));
+const TraceBucket_1 = __importDefault(require("../trace-cluster/TraceBucket"));
 const LeakObjectFilter_1 = require("./leak-filters/LeakObjectFilter");
 const MLTraceSimilarityStrategy_1 = __importDefault(require("../trace-cluster/strategies/MLTraceSimilarityStrategy"));
 class MemoryAnalyst {
     checkLeak() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.visualizeMemoryUsage();
+            MemoryBarChart_1.default.plotMemoryBarChart();
             Utils_1.default.checkSnapshots();
             return yield this.detectMemoryLeaks();
         });
     }
+    diffLeakByWorkDir(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const controlSnapshotDir = FileManager_1.default.getCurDataDir({
+                workDir: options.controlWorkDir,
+            });
+            const treatmentSnapshotDir = FileManager_1.default.getCurDataDir({
+                workDir: options.treatmentWorkDir,
+            });
+            // check control working dir
+            Utils_1.default.checkSnapshots({ snapshotDir: controlSnapshotDir });
+            // check treatment working dir
+            Utils_1.default.checkSnapshots({ snapshotDir: treatmentSnapshotDir });
+            // display control and treatment memory
+            MemoryBarChart_1.default.plotMemoryBarChart(options);
+            return this.diffMemoryLeakTraces(options);
+        });
+    }
+    // find all unique pattern of leaks
+    diffMemoryLeakTraces(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            Config_1.default.dumpNodeInfo = false;
+            // diff snapshots and get control raw paths
+            let snapshotDiff = yield this.diffSnapshots({
+                loadAllSnapshots: true,
+                workDir: options.controlWorkDir,
+            });
+            const controlLeakPaths = this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: options.controlWorkDir });
+            const controlSnapshot = snapshotDiff.snapshot;
+            // diff snapshots and get treatment raw paths
+            snapshotDiff = yield this.diffSnapshots({
+                loadAllSnapshots: true,
+                workDir: options.treatmentWorkDir,
+            });
+            const treatmentLeakPaths = this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: options.controlWorkDir });
+            const treatmentSnapshot = snapshotDiff.snapshot;
+            Console_1.default.topLevel(`${controlLeakPaths.length} traces from control group`);
+            Console_1.default.topLevel(`${treatmentLeakPaths.length} traces from treatment group`);
+            const result = TraceBucket_1.default.clusterControlTreatmentPaths(controlLeakPaths, controlSnapshot, treatmentLeakPaths, treatmentSnapshot, Utils_1.default.aggregateDominatorMetrics, {
+                strategy: Config_1.default.isMLClustering
+                    ? new MLTraceSimilarityStrategy_1.default()
+                    : undefined,
+            });
+            Console_1.default.midLevel(`MemLab found ${result.treatmentOnlyClusters.length} new leak(s) in the treatment group`);
+            yield this.serializeClusterUpdate(result.treatmentOnlyClusters);
+            // TODO (lgong): log leak traces
+            return [];
+        });
+    }
     // find all unique pattern of leaks
     detectMemoryLeaks() {
         return __awaiter(this, void 0, void 0, function* () {
-            const snapshotDiff = yield this.diffSnapshots(true);
+            const snapshotDiff = yield this.diffSnapshots({ loadAllSnapshots: true });
             Config_1.default.dumpNodeInfo = false;
-            const { paths } = yield this.searchLeakedTraces(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot);
+            const paths = yield this.findLeakTraces(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot);
             return LeakTraceDetailsLogger_1.default.logTraces(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, snapshotDiff.listOfLeakedHeapNodeIdSet, paths, Config_1.default.traceJsonOutDir);
         });
     }
-    visualizeMemoryUsage(options = {}) {
-        if (Config_1.default.useExternalSnapshot || options.snapshotDir) {
-            return;
-        }
-        const tabsOrder = Utils_1.default.loadTabsOrder();
-        // if memory usage data is incomplete, skip the visualization
-        for (const tab of tabsOrder) {
-            if (!(tab.JSHeapUsedSize > 0)) {
-                if (Config_1.default.verbose) {
-                    Console_1.default.error('Memory usage data incomplete');
-                }
-                return;
-            }
-        }
-        const plotData = tabsOrder.map((tab, idx) => [
-            idx + 1,
-            ((tab.JSHeapUsedSize / 100000) | 0) / 10,
-        ]);
-        // the graph component cannot handle an array with a single element
-        while (plotData.length < 2) {
-            plotData.push([plotData.length + 1, 0]);
-        }
-        // plot visual settings
-        const minY = 1;
-        const maxY = plotData.reduce((m, v) => Math.max(m, v[1]), 0) * 1.15;
-        const yFractions = 1;
-        const yLabelWidth = 1 +
-            Math.max(minY.toFixed(yFractions).length, maxY.toFixed(yFractions).length);
-        const maxWidth = process.stdout.columns - 10;
-        const idealWidth = Math.max(2 * plotData.length + 2 * yLabelWidth, 10);
-        const plotWidth = Math.min(idealWidth, maxWidth);
-        Console_1.default.topLevel('Memory usage across all steps:');
-        Console_1.default.topLevel((0, babar_1.default)(plotData, {
-            color: 'green',
-            width: plotWidth,
-            height: 10,
-            xFractions: 0,
-            yFractions,
-            minY,
-            maxY,
-        }));
-        Console_1.default.topLevel('');
-    }
     focus(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             Console_1.default.overwrite(`Generating report for node @${Config_1.default.focusFiberNodeId}`);
@@ -113,7 +119,7 @@ class MemoryAnalyst {
             }
             else {
                 Utils_1.default.checkSnapshots();
-                const snapshotDiff = yield this.diffSnapshots(true);
+                const snapshotDiff = yield this.diffSnapshots({ loadAllSnapshots: true });
                 nodeIdsInSnapshots = snapshotDiff.listOfLeakedHeapNodeIdSet;
                 snapshotLeakedHeapNodeIdSet = snapshotDiff.leakedHeapNodeIdSet;
                 snapshot = snapshotDiff.snapshot;
@@ -130,16 +136,16 @@ class MemoryAnalyst {
         }
         return false;
     }
-    diffSnapshots(loadAll = false) {
+    diffSnapshots(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const nodeIdsInSnapshots = [];
-            const tabsOrder = Utils_1.default.loadTabsOrder();
+            const tabsOrder = Utils_1.default.loadTabsOrder(FileManager_1.default.getSnapshotSequenceMetaFile(options));
             // a set keeping track of node ids generated before the target snapshot
             const baselineIds = new Set();
             let collectBaselineIds = true;
             let targetAllocatedHeapNodeIdSet = null;
             let leakedHeapNodeIdSet = null;
-            const options = { verbose: true };
+            const parseSnapshotOptions = { verbose: true, workDir: options.workDir };
             let snapshot = null;
             for (let i = 0; i < tabsOrder.length; i++) {
                 const tab = tabsOrder[i];
@@ -157,13 +163,13 @@ class MemoryAnalyst {
                     continue;
                 }
                 // in quick mode, there is no need to load all snapshots
-                if (!loadAll && !tab.type) {
+                if (!options.loadAllSnapshots && !tab.type) {
                     continue;
                 }
-                const file = Utils_1.default.getSnapshotFilePath(tab);
+                const file = Utils_1.default.getSnapshotFilePath(tab, options);
                 if (this.shouldLoadCompleteSnapshot(tabsOrder, tab)) {
                     // final snapshot needs to build node index
-                    const opt = Object.assign({ buildNodeIdIndex: true }, options);
+                    const opt = Object.assign(Object.assign({ buildNodeIdIndex: true }, parseSnapshotOptions), { workDir: options.workDir });
                     snapshot = yield Utils_1.default.getSnapshotFromFile(file, opt);
                     // record Ids in the snapshot
                     snapshot.nodes.forEach(node => {
@@ -171,7 +177,7 @@ class MemoryAnalyst {
                     });
                 }
                 else {
-                    idsInSnapshot = yield Utils_1.default.getSnapshotNodeIdsFromFile(file, options);
+                    idsInSnapshot = yield Utils_1.default.getSnapshotNodeIdsFromFile(file, parseSnapshotOptions);
                     nodeIdsInSnapshots.pop();
                     nodeIdsInSnapshots.push(idsInSnapshot);
                 }
@@ -234,10 +240,10 @@ class MemoryAnalyst {
         return finder;
     }
     // summarize the page interaction and dump to the leak text summary file
-    dumpPageInteractionSummary() {
-        const tabsOrder = Utils_1.default.loadTabsOrder();
+    dumpPageInteractionSummary(options = {}) {
+        const tabsOrder = Utils_1.default.loadTabsOrder(FileManager_1.default.getSnapshotSequenceMetaFile(options));
         const tabsOrderStr = Serializer_1.default.summarizeTabsOrder(tabsOrder);
-        fs_1.default.writeFileSync(Config_1.default.exploreResultFile, tabsOrderStr, 'UTF-8');
+        fs_1.default.writeFileSync(FileManager_1.default.getLeakSummaryFile(options), tabsOrderStr, 'UTF-8');
     }
     // summarize the leak and print the info in console
     dumpLeakSummaryToConsole(leakedNodeIds, snapshot) {
@@ -318,9 +324,9 @@ class MemoryAnalyst {
             Console_1.default.topLevel(`· ${name}: ${value}`);
         });
     }
-    printHeapAndLeakInfo(leakedNodeIds, snapshot) {
+    printHeapAndLeakInfo(leakedNodeIds, snapshot, options = {}) {
         // write page interaction summary to the leaks text file
-        this.dumpPageInteractionSummary();
+        this.dumpPageInteractionSummary(options);
         // dump leak summry to console
         this.dumpLeakSummaryToConsole(leakedNodeIds, snapshot);
         // get aggregated leak info
@@ -329,42 +335,46 @@ class MemoryAnalyst {
             this.printHeapInfo(heapInfo);
         }
     }
-    logLeakTraceSummary(trace, nodeIdInPaths, snapshot) {
+    logLeakTraceSummary(trace, nodeIdInPaths, snapshot, options = {}) {
         if (!Config_1.default.isFullRun) {
             return;
         }
         // convert the path to a string
         const pathStr = Serializer_1.default.summarizePath(trace, nodeIdInPaths, snapshot);
-        fs_1.default.appendFileSync(Config_1.default.exploreResultFile, `\n\n${pathStr}\n\n`, 'UTF-8');
+        fs_1.default.appendFileSync(FileManager_1.default.getLeakSummaryFile(options), `\n\n${pathStr}\n\n`, 'UTF-8');
+    }
+    filterLeakPaths(leakedNodeIds, snapshot, options = {}) {
+        const finder = this.preparePathFinder(snapshot);
+        this.printHeapAndLeakInfo(leakedNodeIds, snapshot, options);
+        // get all leaked objects
+        this.filterLeakedObjects(leakedNodeIds, snapshot);
+        const nodeIdInPaths = new Set();
+        const paths = [];
+        let numOfLeakedObjects = 0;
+        let i = 0;
+        // analysis for each node
+        Utils_1.default.applyToNodes(leakedNodeIds, snapshot, node => {
+            if (!Config_1.default.isContinuousTest && ++i % 11 === 0) {
+                Console_1.default.overwrite(`progress: ${i} / ${leakedNodeIds.size} @${node.id}`);
+            }
+            // BFS search for path from the leaked node to GC roots
+            const p = finder.getPathToGCRoots(snapshot, node);
+            if (!p || !Utils_1.default.isInterestingPath(p)) {
+                return;
+            }
+            ++numOfLeakedObjects;
+            paths.push(p);
+            this.logLeakTraceSummary(p, nodeIdInPaths, snapshot, options);
+        }, { reverse: true });
+        if (Config_1.default.verbose) {
+            Console_1.default.midLevel(`${numOfLeakedObjects} leaked objects`);
+        }
+        return paths;
     }
     // find unique paths of leaked nodes
-    searchLeakedTraces(leakedNodeIds, snapshot) {
+    findLeakTraces(leakedNodeIds, snapshot, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const finder = this.preparePathFinder(snapshot);
-            this.printHeapAndLeakInfo(leakedNodeIds, snapshot);
-            // get all leaked objects
-            this.filterLeakedObjects(leakedNodeIds, snapshot);
-            const nodeIdInPaths = new Set();
-            const paths = [];
-            let numOfLeakedObjects = 0;
-            let i = 0;
-            // analysis for each node
-            Utils_1.default.applyToNodes(leakedNodeIds, snapshot, node => {
-                if (!Config_1.default.isContinuousTest && ++i % 11 === 0) {
-                    Console_1.default.overwrite(`progress: ${i} / ${leakedNodeIds.size} @${node.id}`);
-                }
-                // BFS search for path from the leaked node to GC roots
-                const p = finder.getPathToGCRoots(snapshot, node);
-                if (!p || !Utils_1.default.isInterestingPath(p)) {
-                    return;
-                }
-                ++numOfLeakedObjects;
-                paths.push(p);
-                this.logLeakTraceSummary(p, nodeIdInPaths, snapshot);
-            }, { reverse: true });
-            if (Config_1.default.verbose) {
-                Console_1.default.midLevel(`${numOfLeakedObjects} leaked objects`);
-            }
+            const paths = this.filterLeakPaths(leakedNodeIds, snapshot, options);
             // cluster traces from the current run
             const clusters = TraceBucket_1.default.clusterPaths(paths, snapshot, Utils_1.default.aggregateDominatorMetrics, {
                 strategy: Config_1.default.isMLClustering
@@ -378,14 +388,12 @@ class MemoryAnalyst {
                 const clustersUnclassified = TraceBucket_1.default.generateUnClassifiedClusters(paths, snapshot, Utils_1.default.aggregateDominatorMetrics);
                 LeakClusterLogger_1.default.logUnclassifiedClusters(clustersUnclassified);
             }
-            return {
-                paths: clusters.map(c => c.path),
-            };
+            return clusters.map(c => c.path);
         });
     }
     /**
      * Given a set of heap object ids, cluster them based on the similarity
-     * of their retainer traces and return a
+     * of their retainer traces
      * @param leakedNodeIds
      * @param snapshot
      * @returns
@@ -429,7 +437,7 @@ class MemoryAnalyst {
             }
         });
     }
-    dumpPathByNodeId(leakedIdSet, snapshot, nodeIdsInSnapshots, id, pathLoaderFile, summaryFile) {
+    dumpPathByNodeId(leakedIdSet, snapshot, nodeIdsInSnapshots, id, pathLoaderFile, summaryFile, options = {}) {
         Console_1.default.overwrite('start analysis...');
         const finder = this.preparePathFinder(snapshot);
         const nodeIdInPaths = new Set();
@@ -443,7 +451,7 @@ class MemoryAnalyst {
                 return;
             }
             LeakTraceDetailsLogger_1.default.logTrace(leakedIdSet, snapshot, nodeIdsInSnapshots, path, pathLoaderFile);
-            const tabsOrder = Utils_1.default.loadTabsOrder();
+            const tabsOrder = Utils_1.default.loadTabsOrder(FileManager_1.default.getSnapshotSequenceMetaFile(options));
             const interactionSummary = Serializer_1.default.summarizeTabsOrder(tabsOrder);
             let pathSummary = Serializer_1.default.summarizePath(path, nodeIdInPaths, snapshot, { color: true });
             Console_1.default.topLevel(pathSummary);

package/dist/lib/Types.d.ts

@@ -47,6 +47,7 @@ export declare type FileOption = {
     workDir?: Optional<string>;
     clear?: boolean;
     transient?: boolean;
+    errorWhenAbsent?: boolean;
 };
 /** @internal */
 export declare type CLIOptions = {
@@ -801,6 +802,15 @@ export declare type TraceClusterMetaInfo = {
     meta_data: string;
 };
 /** @internal */
+export declare type ControlTreatmentClusterResult = {
+    controlOnlyClusters: TraceCluster[];
+    treatmentOnlyClusters: TraceCluster[];
+    hybridClusters: Array<{
+        control: TraceCluster;
+        treatment: TraceCluster;
+    }>;
+};
+/** @internal */
 export interface E2EInteraction {
     kind: string;
     timeout?: number;
@@ -888,6 +898,7 @@ export interface IE2EStepBasic {
 /** @internal */
 export declare type E2EStepInfo = IE2EStepBasic & {
     snapshot: boolean;
+    snapshotFile?: string;
     screenshot: boolean;
     idx: number;
     JSHeapUsedSize: number;
@@ -1209,6 +1220,16 @@ export interface IHeapLocation {
      * get the column number
      */
     column: number;
+    /**
+     * convert to a concise readable string output
+     * (like calling `JSON.stringify(node, ...args)`).
+     * Note: calling `JSON.stringify(node, ...args)` will not work
+     * since the string is too large and not readable.
+     *
+     * This API does not completely serialize all the information
+     * captured by the hosting object.
+     */
+    toJSONString(...args: Array<AnyValue>): string;
 }
 /** @internal */
 export interface IHeapEdgeBasic {
@@ -1281,6 +1302,16 @@ export interface IHeapEdge extends IHeapEdgeBasic {
      * JS heap object where this reference starts
      */
     fromNode: IHeapNode;
+    /**
+     * convert to a concise readable string output
+     * (like calling `JSON.stringify(node, ...args)`).
+     * Note: calling `JSON.stringify(node, ...args)` will not work
+     * since the string is too large and not readable.
+     *
+     * This API does not completely serialize all the information
+     * captured by the hosting object.
+     */
+    toJSONString(...args: Array<AnyValue>): string;
 }
 /**
  * A pseudo array containing all heap graph edges (references to heap objects
@@ -1437,6 +1468,11 @@ export interface IHeapNode extends IHeapNodeBasic {
      * object (including engine-internal, native, and JS references).
      */
     referrers: IHeapEdge[];
+    /**
+     * Get the number of all incoming references pointing to this heap object
+     * (including engine-internal, native, and JS references).
+     */
+    numOfReferrers: number;
     /**
      * returns true if the heap node has been set an incoming edge
      * which leads to the parent node on the shortest path to GC root.
@@ -1484,6 +1520,16 @@ export interface IHeapNode extends IHeapNodeBasic {
      * inside the string node.
      */
     toStringNode(): Nullable<IHeapStringNode>;
+    /**
+     * convert to a concise readable string output
+     * (like calling `JSON.stringify(node, ...args)`).
+     * Note: calling `JSON.stringify(node, ...args)` will not work
+     * since the string is too large and not readable.
+     *
+     * This API does not completely serialize all the information
+     * captured by the hosting object.
+     */
+    toJSONString(...args: Array<AnyValue>): string;
     /**
      * executes a provided callback once for each JavaScript reference in the
      * hosting node (or outgoing edges from the node)
@@ -1554,6 +1600,24 @@ export interface IHeapNode extends IHeapNodeBasic {
      * ```
      */
     findAnyReferrer: (predicate: Predicator<IHeapEdge>) => Nullable<IHeapEdge>;
+    /**
+     * executes a provided predicate callback once for each JavaScript heap
+     * object (heap graph node) pointing to the hosting node
+     * (or nodes having edges to the hosting node) until the predicate
+     * returns `true`
+     * @param predicate the callback for each incoming JavaScript heap object
+     * @returns the first referring node for which the predicate returns `true`,
+     * otherwise returns `null` if no such node is found.
+     *
+     * * **Examples**:
+     * ```typescript
+     * const referrer = node.findAnyReferrerNode((node: IHeapNode) => {
+     *   // find the referring node with name "Parent"
+     *   return node.name === 'Parent';
+     * });
+     * ```
+     */
+    findAnyReferrerNode(predicate: Predicator<IHeapNode>): Nullable<IHeapNode>;
     /**
      * executes a provided predicate callback once for each JavaScript reference
      * pointing to the hosting node (or incoming edges to the node)
@@ -1571,6 +1635,24 @@ export interface IHeapNode extends IHeapNodeBasic {
      * ```
      */
     findReferrers: (predicate: Predicator<IHeapEdge>) => IHeapEdge[];
+    /**
+     * executes a provided predicate callback once for each JavaScript heap
+     * object (heap graph node) pointing to the hosting node
+     * (or nodes having edges to the hosting node)
+     * @param predicate the callback for each referrer nodes
+     * @returns an array containing all the referrer nodes for which the
+     * predicate returns `true`, otherwise returns an empty array if no such
+     * node is found.
+     *
+     * * **Examples**:
+     * ```typescript
+     * const referrerNodes = node.findReferrerNodes((node: IHeapNode) => {
+     *   // find all the referring nodes with name "Parent"
+     *   return node.name === 'Parent';
+     * });
+     * ```
+     */
+    findReferrerNodes: (predicate: Predicator<IHeapNode>) => IHeapNode[];
     /**
      * Given a JS reference's name and type, this API finds an outgoing JS
      * reference from the hosting node.
@@ -1841,6 +1923,17 @@ export interface IOveralLeakInfo extends Partial<IOveralHeapInfo> {
     leakedAlternateFiberNodeSize: number;
 }
 /** @internal */
+export declare type DiffLeakOptions = {
+    controlWorkDir: string;
+    treatmentWorkDir: string;
+};
+/** @internal */
+export declare type PlotMemoryOptions = {
+    controlWorkDir?: string;
+    treatmentWorkDir?: string;
+    workDir?: string;
+} & IMemoryAnalystOptions;
+/** @internal */
 export interface IMemoryAnalystOptions {
     snapshotDir?: string;
     minSnapshots?: number;

package/dist/lib/Utils.d.ts

@@ -95,7 +95,9 @@ declare function checkSnapshots(options?: {
 export declare function resolveSnapshotFilePath(snapshotFile: Nullable<string>): string;
 declare function getSnapshotDirForAnalysis(): string;
 declare function getSingleSnapshotFileForAnalysis(): string;
-declare function getSnapshotFilePath(tab: E2EStepInfo): string;
+declare function getSnapshotFilePath(tab: E2EStepInfo, options?: {
+    workDir?: string;
+}): string;
 declare function equalOrMatch(v1: any, v2: any): boolean;
 declare function getSnapshotFilePathWithTabType(type: string | RegExp): Nullable<string>;
 declare function isMeaningfulNode(node: IHeapNode): boolean;
@@ -123,8 +125,10 @@ declare function isNodeDominatedByDeletionsArray(node: IHeapNode): boolean;
 declare function getUniqueID(): string;
 declare function getClosureSourceUrl(node: IHeapNode): Nullable<string>;
 export declare function runShell(command: string, options?: ShellOptions): Nullable<string>;
-export declare function getRetainedSize(node: IHeapNode): number;
-export declare function aggregateDominatorMetrics(ids: HeapNodeIdSet, snapshot: IHeapSnapshot, checkNodeCb: (node: IHeapNode) => boolean, nodeMetricsCb: (node: IHeapNode) => number): number;
+declare function getRetainedSize(node: IHeapNode): number;
+declare function aggregateDominatorMetrics(ids: HeapNodeIdSet, snapshot: IHeapSnapshot, checkNodeCb: (node: IHeapNode) => boolean, nodeMetricsCb: (node: IHeapNode) => number): number;
+declare function getLeakTracePathLength(path: LeakTracePathItem): number;
+declare function getNumberAtPercentile(arr: number[], percentile: number): number;
 declare const _default: {
     aggregateDominatorMetrics: typeof aggregateDominatorMetrics;
     applyToNodes: typeof applyToNodes;
@@ -147,7 +151,9 @@ declare const _default: {
     getEdgeByNameAndType: typeof getEdgeByNameAndType;
     getLastNodeId: typeof getLastNodeId;
     getLeakedNode: typeof getLeakedNode;
+    getLeakTracePathLength: typeof getLeakTracePathLength;
     getNodesIdSet: typeof getNodesIdSet;
+    getNumberAtPercentile: typeof getNumberAtPercentile;
     getNumberNodeValue: typeof getNumberNodeValue;
     getReadableBytes: typeof getReadableBytes;
     getReadablePercent: typeof getReadablePercent;

package/dist/lib/Utils.js

@@ -44,7 +44,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.aggregateDominatorMetrics = exports.getRetainedSize = exports.runShell = exports.resolveSnapshotFilePath = void 0;
+exports.runShell = exports.resolveSnapshotFilePath = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = __importDefault(require("child_process"));
@@ -1272,7 +1272,7 @@ function checkSnapshots(options = {}) {
         snapshotDir = Config_1.default.externalSnapshotDir || '<missing>';
     }
     else {
-        snapshotDir = FileManager_1.default.getCurDataDir({});
+        snapshotDir = FileManager_1.default.getCurDataDir({ workDir: Config_1.default.workDir });
     }
     if (options.snapshotDir) {
         const snapshots = getSnapshotFilesInDir(snapshotDir);
@@ -1346,13 +1346,20 @@ function getSingleSnapshotFileForAnalysis() {
     }
     return resolveSnapshotFilePath(path);
 }
-function getSnapshotFilePath(tab) {
+function getSnapshotFilePath(tab, options = {}) {
+    if (tab.snapshotFile) {
+        return path_1.default.join(FileManager_1.default.getCurDataDir(options), tab.snapshotFile);
+    }
+    const fileName = `s${tab.idx}.heapsnapshot`;
+    if (options.workDir) {
+        return path_1.default.join(FileManager_1.default.getCurDataDir(options), fileName);
+    }
     if (!Config_1.default.useExternalSnapshot) {
-        return path_1.default.join(Config_1.default.curDataDir, `s${tab.idx}.heapsnapshot`);
+        return path_1.default.join(Config_1.default.curDataDir, fileName);
     }
     // if we are loading snapshot from external snapshot dir
     if (Config_1.default.externalSnapshotDir) {
-        return path_1.default.join(Config_1.default.externalSnapshotDir, `s${tab.idx}.heapsnapshot`);
+        return path_1.default.join(Config_1.default.externalSnapshotDir, fileName);
     }
     return Config_1.default.externalSnapshotFilePaths[tab.idx - 1];
 }
@@ -1786,7 +1793,6 @@ exports.runShell = runShell;
 function getRetainedSize(node) {
     return node.retainedSize;
 }
-exports.getRetainedSize = getRetainedSize;
 function aggregateDominatorMetrics(ids, snapshot, checkNodeCb, nodeMetricsCb) {
     let ret = 0;
     const dominators = __1.utils.getConditionalDominatorIds(ids, snapshot, checkNodeCb);
@@ -1795,7 +1801,29 @@ function aggregateDominatorMetrics(ids, snapshot, checkNodeCb, nodeMetricsCb) {
     });
     return ret;
 }
-exports.aggregateDominatorMetrics = aggregateDominatorMetrics;
+function getLeakTracePathLength(path) {
+    let len = 0;
+    let p = path;
+    while (p) {
+        p = p.next;
+        ++len;
+    }
+    return len;
+}
+function getNumberAtPercentile(arr, percentile) {
+    arr.sort(function (a, b) {
+        return a - b;
+    });
+    const index = (percentile / 100) * arr.length;
+    const indexInt = Math.floor(index);
+    if (indexInt === index) {
+        return arr[Math.floor(index)];
+    }
+    if (indexInt + 1 < arr.length) {
+        return (arr[indexInt] + arr[indexInt + 1]) / 2;
+    }
+    return arr[indexInt];
+}
 exports.default = {
     aggregateDominatorMetrics,
     applyToNodes,
@@ -1818,7 +1846,9 @@ exports.default = {
     getEdgeByNameAndType,
     getLastNodeId,
     getLeakedNode,
+    getLeakTracePathLength,
     getNodesIdSet,
+    getNumberAtPercentile,
     getNumberNodeValue,
     getReadableBytes,
     getReadablePercent,

package/dist/lib/charts/MemoryBarChart.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 { PlotMemoryOptions } from '../Types';
+declare class MemoryBarChart {
+    plotMemoryBarChart(options?: PlotMemoryOptions): void;
+    private loadPlotDataFromTabsOrder;
+    private loadPlotDataFromWorkDir;
+    private loadPlotData;
+    private mergePlotData;
+}
+declare const _default: MemoryBarChart;
+export default _default;
+//# sourceMappingURL=MemoryBarChart.d.ts.map