@memlab/core 1.0.0

package/dist/lib/HeapAnalyzer.js

@@ -0,0 +1,719 @@
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+'use strict';
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const babar_1 = __importDefault(require("babar"));
+const chalk_1 = __importDefault(require("chalk"));
+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"));
+class MemoryAnalyst {
+    checkLeak() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.visualizeMemoryUsage();
+            Utils_1.default.checkSnapshots();
+            yield this.detectMemoryLeaks();
+        });
+    }
+    checkUnbound(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.visualizeMemoryUsage(options);
+            Utils_1.default.checkSnapshots(options);
+            yield this.detectUnboundGrowth(options);
+        });
+    }
+    breakDownMemoryByShapes(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opt = { buildNodeIdIndex: true, verbose: true };
+            const file = options.file ||
+                Utils_1.default.getSnapshotFilePathWithTabType(/.*/) ||
+                '<EMPTY_FILE_PATH>';
+            const snapshot = yield Utils_1.default.getSnapshotFromFile(file, opt);
+            this.preparePathFinder(snapshot);
+            const heapInfo = this.getOverallHeapInfo(snapshot, { force: true });
+            if (heapInfo) {
+                this.printHeapInfo(heapInfo);
+            }
+            this.breakDownSnapshotByShapes(snapshot);
+        });
+    }
+    // find any objects that keeps growing
+    detectUnboundGrowth(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nodeInfo = Object.create(null);
+            let hasCheckedFirstSnapshot = false;
+            let snapshot = null;
+            const isValidNode = (node) => node.type === 'object' ||
+                node.type === 'closure' ||
+                node.type === 'regexp';
+            const initNodeInfo = (node) => {
+                if (!isValidNode(node)) {
+                    return;
+                }
+                const n = node.retainedSize;
+                nodeInfo[node.id] = {
+                    type: node.type,
+                    name: node.name,
+                    min: n,
+                    max: n,
+                    history: [n],
+                    node,
+                };
+            };
+            const updateNodeInfo = (node) => {
+                const item = nodeInfo[node.id];
+                if (!item) {
+                    return;
+                }
+                if (node.name !== item.name || node.type !== item.type) {
+                    nodeInfo[node.id] = null;
+                    return;
+                }
+                const n = node.retainedSize;
+                // only monotonic increase?
+                if (Config_1.default.monotonicUnboundGrowthOnly && n < item.max) {
+                    nodeInfo[node.id] = null;
+                    return;
+                }
+                item.history.push(n);
+                item.max = Math.max(item.max, n);
+                item.min = Math.min(item.min, n);
+            };
+            // summarize the heap objects info in current heap snapshot
+            // this is mainly used for better understanding of the % of
+            // objects released and allocated over time
+            const maybeSummarizeNodeInfo = () => {
+                if (!Config_1.default.verbose) {
+                    return;
+                }
+                let n = 0;
+                for (const k in nodeInfo) {
+                    if (nodeInfo[k]) {
+                        ++n;
+                    }
+                }
+                Console_1.default.lowLevel(`Objects tracked: ${n}`);
+            };
+            Console_1.default.overwrite('Checking unbounded objects...');
+            const snapshotFiles = options.snapshotDir
+                ? // load snapshots from a directory
+                    Utils_1.default.getSnapshotFilesInDir(options.snapshotDir)
+                : // load snapshots based on the visit sequence meta data
+                    Utils_1.default.getSnapshotFilesFromTabsOrder();
+            for (const file of snapshotFiles) {
+                // force GC before loading each snapshot
+                if (global.gc) {
+                    global.gc();
+                }
+                // load and preprocess heap snapshot
+                const opt = { buildNodeIdIndex: true, verbose: true };
+                snapshot = yield Utils_1.default.getSnapshotFromFile(file, opt);
+                this.calculateRetainedSizes(snapshot);
+                // keep track of heap objects
+                if (!hasCheckedFirstSnapshot) {
+                    // record Ids in the snapshot
+                    snapshot.nodes.forEach(initNodeInfo);
+                    hasCheckedFirstSnapshot = true;
+                }
+                else {
+                    snapshot.nodes.forEach(updateNodeInfo);
+                    maybeSummarizeNodeInfo();
+                }
+            }
+            // exit if no heap snapshot found
+            if (!hasCheckedFirstSnapshot) {
+                return;
+            }
+            // post process and print the unbounded objects
+            const idsInLastSnapshot = new Set();
+            snapshot === null || snapshot === void 0 ? void 0 : snapshot.nodes.forEach(node => {
+                idsInLastSnapshot.add(node.id);
+            });
+            let ids = [];
+            for (const key in nodeInfo) {
+                const id = parseInt(key, 10);
+                const item = nodeInfo[id];
+                if (!item) {
+                    continue;
+                }
+                if (!idsInLastSnapshot.has(id)) {
+                    continue;
+                }
+                if (item.min === item.max) {
+                    continue;
+                }
+                // filter out non-significant leaks
+                if (item.history[item.history.length - 1] < Config_1.default.unboundSizeThreshold) {
+                    continue;
+                }
+                ids.push(Object.assign({ id }, item));
+            }
+            if (ids.length === 0) {
+                Console_1.default.midLevel('No increasing objects found.');
+                return;
+            }
+            ids = ids
+                .sort((o1, o2) => o2.history[o2.history.length - 1] - o1.history[o1.history.length - 1])
+                .slice(0, 20);
+            // print on terminal
+            const str = Serializer_1.default.summarizeUnboundedObjects(ids, { color: true });
+            Console_1.default.topLevel('Top growing objects in sizes:');
+            Console_1.default.lowLevel(' (Use `memlab report --nodeId=@ID` to get trace)');
+            Console_1.default.topLevel('\n' + str);
+            // save results to file
+            const csv = Serializer_1.default.summarizeUnboundedObjectsToCSV(ids);
+            fs_1.default.writeFileSync(Config_1.default.unboundObjectCSV, csv, 'UTF-8');
+        });
+    }
+    // find all unique pattern of leaks
+    detectMemoryLeaks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshotDiff = yield this.diffSnapshots(true);
+            Config_1.default.dumpNodeInfo = false;
+            const { paths } = yield this.searchLeakedTraces(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot);
+            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}`);
+            let snapshotLeakedHeapNodeIdSet = new Set();
+            let nodeIdsInSnapshots = [];
+            let snapshot;
+            if (options.file) {
+                const opt = { buildNodeIdIndex: true, verbose: true };
+                snapshot = yield Utils_1.default.getSnapshotFromFile(options.file, opt);
+            }
+            else {
+                Utils_1.default.checkSnapshots();
+                const snapshotDiff = yield this.diffSnapshots(true);
+                nodeIdsInSnapshots = snapshotDiff.listOfLeakedHeapNodeIdSet;
+                snapshotLeakedHeapNodeIdSet = snapshotDiff.leakedHeapNodeIdSet;
+                snapshot = snapshotDiff.snapshot;
+            }
+            this.dumpPathByNodeId(snapshotLeakedHeapNodeIdSet, snapshot, nodeIdsInSnapshots, Config_1.default.focusFiberNodeId, Config_1.default.viewJsonFile, Config_1.default.singleReportSummary);
+        });
+    }
+    shouldLoadCompleteSnapshot(tabsOrder, tab) {
+        for (let i = tabsOrder.length - 1; i >= 0; --i) {
+            const curTab = tabsOrder[i];
+            if (curTab.type === 'target' || curTab.type === 'final') {
+                return curTab === tab;
+            }
+        }
+        return false;
+    }
+    diffSnapshots(loadAll = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nodeIdsInSnapshots = [];
+            const tabsOrder = Utils_1.default.loadTabsOrder();
+            // 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 };
+            let snapshot = null;
+            for (let i = 0; i < tabsOrder.length; i++) {
+                const tab = tabsOrder[i];
+                // force GC before loading each snapshot
+                if (global.gc) {
+                    global.gc();
+                }
+                // when we see the target snapshot, stop collecting node ids allocated so far
+                if (tab.type === 'target') {
+                    collectBaselineIds = false;
+                }
+                let idsInSnapshot = new Set();
+                nodeIdsInSnapshots.push(idsInSnapshot);
+                if (!tab.snapshot) {
+                    continue;
+                }
+                // in quick mode, there is no need to load all snapshots
+                if (!loadAll && !tab.type) {
+                    continue;
+                }
+                const file = Utils_1.default.getSnapshotFilePath(tab);
+                if (this.shouldLoadCompleteSnapshot(tabsOrder, tab)) {
+                    // final snapshot needs to build node index
+                    const opt = Object.assign({ buildNodeIdIndex: true }, options);
+                    snapshot = yield Utils_1.default.getSnapshotFromFile(file, opt);
+                    // record Ids in the snapshot
+                    snapshot.nodes.forEach(node => {
+                        idsInSnapshot.add(node.id);
+                    });
+                }
+                else {
+                    idsInSnapshot = yield Utils_1.default.getSnapshotNodeIdsFromFile(file, options);
+                    nodeIdsInSnapshots.pop();
+                    nodeIdsInSnapshots.push(idsInSnapshot);
+                }
+                // collect all node ids allocated before the target snapshot
+                if (collectBaselineIds) {
+                    for (const id of idsInSnapshot) {
+                        baselineIds.add(id);
+                    }
+                }
+                if (tab.type === 'target') {
+                    targetAllocatedHeapNodeIdSet = new Set();
+                    idsInSnapshot.forEach(id => {
+                        if (!baselineIds.has(id)) {
+                            targetAllocatedHeapNodeIdSet === null || targetAllocatedHeapNodeIdSet === void 0 ? void 0 : targetAllocatedHeapNodeIdSet.add(id);
+                        }
+                    });
+                    // if final snapshot is not present,
+                    // search leaks among `Set { target } \ Set { baseline }`
+                    leakedHeapNodeIdSet = targetAllocatedHeapNodeIdSet;
+                }
+                if (tab.type === 'final') {
+                    if (!targetAllocatedHeapNodeIdSet) {
+                        Utils_1.default.haltOrThrow('no target snapshot before finals snapshot');
+                    }
+                    leakedHeapNodeIdSet = new Set();
+                    snapshot === null || snapshot === void 0 ? void 0 : snapshot.nodes.forEach(node => {
+                        if (targetAllocatedHeapNodeIdSet === null || targetAllocatedHeapNodeIdSet === void 0 ? void 0 : targetAllocatedHeapNodeIdSet.has(node.id)) {
+                            leakedHeapNodeIdSet === null || leakedHeapNodeIdSet === void 0 ? void 0 : leakedHeapNodeIdSet.add(node.id);
+                        }
+                    });
+                    targetAllocatedHeapNodeIdSet = null;
+                }
+            }
+            if (!snapshot || !leakedHeapNodeIdSet) {
+                throw Utils_1.default.haltOrThrow('Snapshot incomplete', {
+                    printErrorBeforeHalting: true,
+                });
+            }
+            return {
+                leakedHeapNodeIdSet: leakedHeapNodeIdSet,
+                snapshot,
+                listOfLeakedHeapNodeIdSet: nodeIdsInSnapshots,
+            };
+        });
+    }
+    calculateRetainedSizes(snapshot) {
+        const finder = new TraceFinder_1.default();
+        // dominator and retained size
+        finder.calculateAllNodesRetainedSizes(snapshot);
+    }
+    // initialize the path finder
+    preparePathFinder(snapshot) {
+        const finder = new TraceFinder_1.default();
+        // shortest path for all nodes
+        finder.annotateShortestPaths(snapshot);
+        // dominator and retained size
+        finder.calculateAllNodesRetainedSizes(snapshot);
+        // mark detached Fiber nodes
+        Utils_1.default.markAllDetachedFiberNode(snapshot);
+        // mark alternate Fiber nodes
+        Utils_1.default.markAlternateFiberNode(snapshot);
+        return finder;
+    }
+    // summarize the page interaction and dump to the leak text summary file
+    dumpPageInteractionSummary() {
+        const tabsOrder = Utils_1.default.loadTabsOrder();
+        const tabsOrderStr = Serializer_1.default.summarizeTabsOrder(tabsOrder);
+        fs_1.default.writeFileSync(Config_1.default.exploreResultFile, tabsOrderStr, 'UTF-8');
+    }
+    // summarize the leak and print the info in console
+    dumpLeakSummaryToConsole(leakedNodeIds, snapshot) {
+        if (!Config_1.default.verbose && !Config_1.default.useExternalSnapshot) {
+            return;
+        }
+        Console_1.default.overwrite('summarizing snapshot diff...');
+        const aggregatedLeakSummaryDict = Object.create(null);
+        // count the distribution of nodes
+        Utils_1.default.applyToNodes(leakedNodeIds, snapshot, node => {
+            if (!Utils_1.default.isDebuggableNode(node)) {
+                return false;
+            }
+            const key = `${node.name} (${node.type})`;
+            const leakSummary = (aggregatedLeakSummaryDict[key] =
+                aggregatedLeakSummaryDict[key] || {
+                    name: node.name,
+                    type: node.type,
+                    count: 0,
+                    retainedSize: 0,
+                });
+            leakSummary.count++;
+            leakSummary.retainedSize += node.retainedSize | 0;
+        });
+        const list = Object.entries(aggregatedLeakSummaryDict)
+            .sort((e1, e2) => e2[1].retainedSize - e1[1].retainedSize)
+            .slice(0, 20)
+            .map(entry => {
+            const ret = Object.assign(entry[1]);
+            ret.retainedSize = Utils_1.default.getReadableBytes(ret.retainedSize);
+            return ret;
+        });
+        Console_1.default.topLevel('Alive objects allocated in target page:');
+        Console_1.default.table(list);
+    }
+    checkDetachedFiberNode(node) {
+        if (!Config_1.default.detectFiberNodeLeak ||
+            !Utils_1.default.isFiberNode(node) ||
+            Utils_1.default.hasHostRoot(node)) {
+            return false;
+        }
+        return !Utils_1.default.isNodeDominatedByDeletionsArray(node);
+    }
+    isTrivialNode(node) {
+        return (node.type === 'number' ||
+            Utils_1.default.isStringNode(node) ||
+            node.type === 'hidden');
+    }
+    filterLeakedObjects(leakedNodeIds, snapshot) {
+        var _a;
+        // call init leak filter hook if exists
+        if ((_a = Config_1.default.externalLeakFilter) === null || _a === void 0 ? void 0 : _a.beforeLeakFilter) {
+            Config_1.default.externalLeakFilter.beforeLeakFilter(snapshot, leakedNodeIds);
+        }
+        // start filtering memory leaks
+        Utils_1.default.filterNodesInPlace(leakedNodeIds, snapshot, node => {
+            // use external leak filter if exists
+            if (Config_1.default.externalLeakFilter) {
+                return Config_1.default.externalLeakFilter.leakFilter(node, snapshot, leakedNodeIds);
+            }
+            if (this.isTrivialNode(node)) {
+                return false;
+            }
+            // when analyzing hermes heap snapshots, filter Hermes internal objects
+            if (Config_1.default.jsEngine === 'hermes' && Utils_1.default.isHermesInternalObject(node)) {
+                return false;
+            }
+            if (Config_1.default.oversizeObjectAsLeak) {
+                return node.retainedSize > Config_1.default.oversizeThreshold;
+            }
+            // check FiberNodes without a Fiber Root
+            if (this.checkDetachedFiberNode(node)) {
+                return true;
+            }
+            const isDetached = Utils_1.default.isDetachedDOMNode(node, {
+                ignoreInternalNode: true,
+            });
+            if (isDetached && Config_1.default.targetApp === 'ads-manager') {
+                return Utils_1.default.hasReactEdges(node);
+            }
+            return isDetached || Utils_1.default.isStackTraceFrame(node);
+        });
+        if (Config_1.default.verbose) {
+            Console_1.default.midLevel(`${leakedNodeIds.size} Fiber nodes and Detached elements`);
+        }
+    }
+    aggregateDominatorMetrics(ids, snapshot, checkNodeCb, nodeMetricsCb) {
+        let ret = 0;
+        const dominators = Utils_1.default.getConditionalDominatorIds(ids, snapshot, checkNodeCb);
+        Utils_1.default.applyToNodes(dominators, snapshot, node => {
+            ret += nodeMetricsCb(node);
+        });
+        return ret;
+    }
+    getOverallHeapInfo(snapshot, options = {}) {
+        if (!Config_1.default.verbose && !options.force) {
+            return;
+        }
+        Console_1.default.overwrite('summarizing heap info...');
+        const allIds = Utils_1.default.getNodesIdSet(snapshot);
+        const heapInfo = {
+            fiberNodeSize: this.aggregateDominatorMetrics(allIds, snapshot, Utils_1.default.isFiberNode, this.getRetainedSize),
+            regularFiberNodeSize: this.aggregateDominatorMetrics(allIds, snapshot, Utils_1.default.isRegularFiberNode, this.getRetainedSize),
+            detachedFiberNodeSize: this.aggregateDominatorMetrics(allIds, snapshot, Utils_1.default.isDetachedFiberNode, this.getRetainedSize),
+            alternateFiberNodeSize: this.aggregateDominatorMetrics(allIds, snapshot, Utils_1.default.isAlternateNode, this.getRetainedSize),
+            error: this.aggregateDominatorMetrics(allIds, snapshot, node => node.name === 'Error', this.getRetainedSize),
+        };
+        return heapInfo;
+    }
+    getRetainedSize(node) {
+        return node.retainedSize;
+    }
+    getOverallLeakInfo(leakedNodeIds, snapshot) {
+        if (!Config_1.default.verbose) {
+            return;
+        }
+        const leakInfo = Object.assign(Object.assign({}, this.getOverallHeapInfo(snapshot)), { leakedSize: this.aggregateDominatorMetrics(leakedNodeIds, snapshot, () => true, this.getRetainedSize), leakedFiberNodeSize: this.aggregateDominatorMetrics(leakedNodeIds, snapshot, Utils_1.default.isFiberNode, this.getRetainedSize), leakedAlternateFiberNodeSize: this.aggregateDominatorMetrics(leakedNodeIds, snapshot, Utils_1.default.isAlternateNode, this.getRetainedSize) });
+        return leakInfo;
+    }
+    printHeapInfo(leakInfo) {
+        Object.entries(leakInfo)
+            .map(([k, v]) => [
+            Utils_1.default.camelCaseToReadableString(k),
+            Utils_1.default.getReadableBytes(v),
+        ])
+            .forEach(([name, value]) => {
+            Console_1.default.topLevel(`· ${name}: ${value}`);
+        });
+    }
+    breakDownSnapshotByShapes(snapshot) {
+        Console_1.default.overwrite('Breaking down memory by shapes...');
+        const breakdown = Object.create(null);
+        const population = Object.create(null);
+        // group objects based on their shapes
+        snapshot.nodes.forEach(node => {
+            if ((node.type !== 'object' && !Utils_1.default.isStringNode(node)) ||
+                Config_1.default.nodeIgnoreSetInShape.has(node.name)) {
+                return;
+            }
+            const key = Serializer_1.default.summarizeNodeShape(node);
+            breakdown[key] = breakdown[key] || new Set();
+            breakdown[key].add(node.id);
+            if (population[key] === undefined) {
+                population[key] = { examples: [], n: 0 };
+            }
+            ++population[key].n;
+            // retain the top 5 examples
+            const examples = population[key].examples;
+            examples.push(node);
+            examples.sort((n1, n2) => n2.retainedSize - n1.retainedSize);
+            if (examples.length > 5) {
+                examples.pop();
+            }
+        });
+        // calculate and sort based on retained sizes
+        const ret = [];
+        for (const key in breakdown) {
+            const size = this.aggregateDominatorMetrics(breakdown[key], snapshot, () => true, this.getRetainedSize);
+            ret.push({ key, retainedSize: size });
+        }
+        ret.sort((o1, o2) => o2.retainedSize - o1.retainedSize);
+        Console_1.default.topLevel('Object shapes with top retained sizes:');
+        Console_1.default.lowLevel(' (Use `memlab report --nodeId=@ID` to get trace)\n');
+        const topList = ret.slice(0, 40);
+        // print settings
+        const opt = { color: true, compact: true };
+        const dot = chalk_1.default.grey('· ');
+        const colon = chalk_1.default.grey(': ');
+        // print the shapes with the biggest retained size
+        for (const o of topList) {
+            const referrerInfo = this.breakDownByReferrers(breakdown[o.key], snapshot);
+            const { examples, n } = population[o.key];
+            const shapeStr = Serializer_1.default.summarizeNodeShape(examples[0], opt);
+            const bytes = Utils_1.default.getReadableBytes(o.retainedSize);
+            const examplesStr = examples
+                .map(e => `@${e.id} [${Utils_1.default.getReadableBytes(e.retainedSize)}]`)
+                .join(' | ');
+            const meta = chalk_1.default.grey(` (N: ${n}, Examples: ${examplesStr})`);
+            Console_1.default.topLevel(`${dot}${shapeStr}${colon}${bytes}${meta}`);
+            Console_1.default.lowLevel(referrerInfo + '\n');
+        }
+    }
+    isTrivialEdgeForBreakDown(edge) {
+        const source = edge.fromNode;
+        return (source.type === 'array' ||
+            source.name === '(object elements)' ||
+            source.name === 'system' ||
+            edge.name_or_index === '__proto__' ||
+            edge.name_or_index === 'prototype');
+    }
+    breakDownByReferrers(ids, snapshot) {
+        const edgeNames = Object.create(null);
+        for (const id of ids) {
+            const node = snapshot.getNodeById(id);
+            for (const edge of (node === null || node === void 0 ? void 0 : node.referrers) || []) {
+                const source = edge.fromNode;
+                if (!Utils_1.default.isMeaningfulEdge(edge) ||
+                    this.isTrivialEdgeForBreakDown(edge)) {
+                    continue;
+                }
+                const sourceName = Serializer_1.default.summarizeNodeName(source, {
+                    color: false,
+                });
+                const edgeName = Serializer_1.default.summarizeEdgeName(edge, {
+                    color: false,
+                    abstract: true,
+                });
+                const edgeKey = `[${sourceName}] --${edgeName}--> `;
+                edgeNames[edgeKey] = edgeNames[edgeKey] || {
+                    numberOfEdgesToNode: 0,
+                    source,
+                    edge,
+                };
+                ++edgeNames[edgeKey].numberOfEdgesToNode;
+            }
+        }
+        const referrerInfo = Object.entries(edgeNames)
+            .sort((i1, i2) => i2[1].numberOfEdgesToNode - i1[1].numberOfEdgesToNode)
+            .slice(0, 4)
+            .map(i => {
+            const meta = i[1];
+            const source = Serializer_1.default.summarizeNodeName(meta.source, {
+                color: true,
+            });
+            const edgeName = Serializer_1.default.summarizeEdgeName(meta.edge, {
+                color: true,
+                abstract: true,
+            });
+            const edgeSummary = `${source} --${edgeName}-->`;
+            return `  · ${edgeSummary}: ${meta.numberOfEdgesToNode}`;
+        })
+            .join('\n');
+        return referrerInfo;
+    }
+    // find unique paths of leaked nodes
+    searchLeakedTraces(leakedNodeIds, snapshot) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const finder = this.preparePathFinder(snapshot);
+            // write page interaction summary to the leaks text file
+            this.dumpPageInteractionSummary();
+            // dump leak summry to console
+            this.dumpLeakSummaryToConsole(leakedNodeIds, snapshot);
+            // get all leaked objects
+            this.filterLeakedObjects(leakedNodeIds, snapshot);
+            // get aggregated leak info
+            const leakInfo = this.getOverallHeapInfo(snapshot);
+            if (leakInfo) {
+                this.printHeapInfo(leakInfo);
+            }
+            if (Config_1.default.verbose) {
+                // show a breakdown of different object structures
+                this.breakDownSnapshotByShapes(snapshot);
+            }
+            let numOfLeakedObjects = 0;
+            let i = 0;
+            const nodeIdInPaths = new Set();
+            const paths = [];
+            // 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) {
+                    return;
+                }
+                if (!Utils_1.default.isInterestingPath(p)) {
+                    return;
+                }
+                ++numOfLeakedObjects;
+                paths.push(p);
+                // convert the path to a string
+                if (Config_1.default.isFullRun) {
+                    const pathStr = Serializer_1.default.summarizePath(p, nodeIdInPaths, snapshot);
+                    fs_1.default.appendFileSync(Config_1.default.exploreResultFile, `\n\n${pathStr}\n\n`, 'UTF-8');
+                }
+            }, { reverse: true });
+            if (Config_1.default.verbose) {
+                Console_1.default.midLevel(`${numOfLeakedObjects} leaked objects`);
+            }
+            // cluster traces from the current run
+            const clusters = TraceBucket_1.default.clusterPaths(paths, snapshot, this.aggregateDominatorMetrics);
+            yield this.serializeClusterUpdate(clusters);
+            if (Config_1.default.logUnclassifiedClusters) {
+                // cluster traces from the current run
+                const clustersUnclassified = TraceBucket_1.default.generateUnClassifiedClusters(paths, snapshot, this.aggregateDominatorMetrics);
+                LeakClusterLogger_1.default.logUnclassifiedClusters(clustersUnclassified);
+            }
+            return {
+                paths: clusters.map(c => c.path),
+            };
+        });
+    }
+    serializeClusterUpdate(clusters, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // load existing clusters
+            const existingClusters = yield LeakClusterLogger_1.default.loadClusters(Config_1.default.currentUniqueClusterDir);
+            // figure out stale and new clusters
+            const clusterDiff = TraceBucket_1.default.diffClusters(clusters, existingClusters);
+            if (options.reclusterOnly) {
+                // only recluster updates
+                LeakClusterLogger_1.default.logClusterDiff(clusterDiff);
+            }
+            else {
+                // log clusters traces for the current run
+                LeakClusterLogger_1.default.logClusters(clusters, { clusterDiff });
+            }
+        });
+    }
+    dumpPathByNodeId(leakedIdSet, snapshot, nodeIdsInSnapshots, id, pathLoaderFile, summaryFile) {
+        Console_1.default.overwrite('start analysis...');
+        const finder = this.preparePathFinder(snapshot);
+        const nodeIdInPaths = new Set();
+        const idSet = new Set([id]);
+        LeakTraceDetailsLogger_1.default.setTraceFileEmpty(pathLoaderFile);
+        fs_1.default.writeFileSync(summaryFile, 'no path found', 'UTF-8');
+        Utils_1.default.applyToNodes(idSet, snapshot, node => {
+            const path = finder.getPathToGCRoots(snapshot, node);
+            if (!path) {
+                Console_1.default.topLevel(`path for node @${id} is not found`);
+                return;
+            }
+            LeakTraceDetailsLogger_1.default.logTrace(leakedIdSet, snapshot, nodeIdsInSnapshots, path, pathLoaderFile);
+            const tabsOrder = Utils_1.default.loadTabsOrder();
+            const interactionSummary = Serializer_1.default.summarizeTabsOrder(tabsOrder);
+            let pathSummary = Serializer_1.default.summarizePath(path, nodeIdInPaths, snapshot, { color: true });
+            Console_1.default.topLevel(pathSummary);
+            pathSummary = Serializer_1.default.summarizePath(path, nodeIdInPaths, snapshot);
+            const summary = `Page Interaction: \n${interactionSummary}\n\n` +
+                `Path from GC Root to Leaked Object:\n${pathSummary}`;
+            fs_1.default.writeFileSync(summaryFile, summary, 'UTF-8');
+        });
+    }
+}
+exports.default = new MemoryAnalyst();