@memlab/heap-analysis 1.0.0

package/dist/plugins/ObjectUnboundGrowthAnalysis.js

@@ -0,0 +1,47 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+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 core_1 = require("@memlab/core");
+const BaseAnalysis_1 = __importDefault(require("../BaseAnalysis"));
+const HeapAnalysisSnapshotDirectoryOption_1 = __importDefault(require("../options/HeapAnalysisSnapshotDirectoryOption"));
+const PluginUtils_1 = __importDefault(require("../PluginUtils"));
+class ObjectUnboundGrowthAnalysis extends BaseAnalysis_1.default {
+    getCommandName() {
+        return 'unbound-object';
+    }
+    getDescription() {
+        return 'Check unbound object growth';
+    }
+    getOptions() {
+        return [new HeapAnalysisSnapshotDirectoryOption_1.default()];
+    }
+    process(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshotDir = PluginUtils_1.default.getSnapshotDirForAnalysis(options);
+            const opt = snapshotDir ? { minSnapshots: 2, snapshotDir } : {};
+            core_1.config.chaseWeakMapEdge = false;
+            yield core_1.analysis.checkUnbound(opt);
+        });
+    }
+}
+exports.default = ObjectUnboundGrowthAnalysis;

package/dist/plugins/ShapeUnboundGrowthAnalysis.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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
+ */
+import type { IHeapSnapshot } from '@memlab/core';
+import type { HeapAnalysisOptions } from '../PluginUtils';
+import { BaseOption } from '@memlab/core';
+import BaseAnalysis from '../BaseAnalysis';
+declare type ShapesInfo = {
+    [shape: string]: ShapeInfo;
+};
+declare type ShapeInfo = {
+    shape: string;
+    n: number;
+    examples: number[];
+    size: number;
+    ids: Set<number>;
+};
+declare type ShapeSummary = {
+    shape: string;
+    counts: number[];
+    sizes: number[];
+    examples: number[];
+};
+export default class ShapeUnboundGrowthAnalysis extends BaseAnalysis {
+    getCommandName(): string;
+    getDescription(): string;
+    getOptions(): BaseOption[];
+    private shapesOfInterest;
+    process(options: HeapAnalysisOptions): Promise<ShapeSummary[]>;
+    private retrieveShapesOfInterest;
+    getShapesInfo(snapshot: IHeapSnapshot): ShapesInfo;
+    getSummary(ShapesInfoList: ShapesInfo[]): ShapeSummary[];
+    private print;
+}
+export {};
+//# sourceMappingURL=ShapeUnboundGrowthAnalysis.d.ts.map

package/dist/plugins/ShapeUnboundGrowthAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShapeUnboundGrowthAnalysis.d.ts","sourceRoot":"","sources":["../../src/plugins/ShapeUnboundGrowthAnalysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,aAAa,EAAW,MAAM,cAAc,CAAC;AAC1D,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAGxD,OAAO,EAAC,UAAU,EAAkC,MAAM,cAAc,CAAC;AAEzE,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAG3C,aAAK,UAAU,GAAG;IAChB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B,CAAC;AAEF,aAAK,SAAS,GAAG;IACf,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAClB,CAAC;AAEF,aAAK,YAAY,GAAG;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,0BAA2B,SAAQ,YAAY;IAC3D,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAI/B,UAAU,IAAI,UAAU,EAAE;IAI1B,OAAO,CAAC,gBAAgB,CAA+B;IAE1C,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAoB3E,OAAO,CAAC,wBAAwB;IAOhC,aAAa,CAAC,QAAQ,EAAE,aAAa,GAAG,UAAU;IAoDlD,UAAU,CAAC,cAAc,EAAE,UAAU,EAAE,GAAG,YAAY,EAAE;IAyDxD,OAAO,CAAC,KAAK;CAmBd"}

package/dist/plugins/ShapeUnboundGrowthAnalysis.js

@@ -0,0 +1,164 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+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 chalk_1 = __importDefault(require("chalk"));
+const core_1 = require("@memlab/core");
+const HeapAnalysisSnapshotDirectoryOption_1 = __importDefault(require("../options/HeapAnalysisSnapshotDirectoryOption"));
+const BaseAnalysis_1 = __importDefault(require("../BaseAnalysis"));
+const PluginUtils_1 = __importDefault(require("../PluginUtils"));
+class ShapeUnboundGrowthAnalysis extends BaseAnalysis_1.default {
+    constructor() {
+        super(...arguments);
+        this.shapesOfInterest = null;
+    }
+    getCommandName() {
+        return 'unbound-shape';
+    }
+    getDescription() {
+        return 'Get shapes with unbound growth';
+    }
+    getOptions() {
+        return [new HeapAnalysisSnapshotDirectoryOption_1.default()];
+    }
+    process(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let list = yield PluginUtils_1.default.snapshotMapReduce(this.getShapesInfo.bind(this), this.getSummary, options);
+            this.retrieveShapesOfInterest(list);
+            list = yield PluginUtils_1.default.snapshotMapReduce(this.getShapesInfo.bind(this), this.getSummary, options);
+            this.shapesOfInterest = null;
+            this.print(list);
+            return list;
+        });
+    }
+    retrieveShapesOfInterest(list) {
+        this.shapesOfInterest = new Set();
+        for (const summary of list) {
+            this.shapesOfInterest.add(summary.shape);
+        }
+    }
+    getShapesInfo(snapshot) {
+        const population = Object.create(null);
+        const shapes = this.shapesOfInterest;
+        // group objects based on their shapes
+        snapshot.nodes.forEach(node => {
+            if ((node.type !== 'object' && !core_1.utils.isStringNode(node)) ||
+                core_1.config.nodeIgnoreSetInShape.has(node.name)) {
+                return;
+            }
+            const key = core_1.serializer.summarizeNodeShape(node, { color: true });
+            if (shapes && !shapes.has(key)) {
+                return;
+            }
+            population[key] =
+                population[key] ||
+                    {
+                        shape: key,
+                        n: 0,
+                        examples: [],
+                        ids: new Set(),
+                    };
+            const record = population[key];
+            ++record.n;
+            if (record.examples.length < 3) {
+                record.examples.push(node.id);
+            }
+            if (shapes && shapes.has(key)) {
+                record.ids.add(node.id);
+            }
+        });
+        if (shapes) {
+            for (const record of Object.values(population)) {
+                record.size = PluginUtils_1.default.aggregateDominatorMetrics(record.ids, snapshot, () => true, node => node.retainedSize);
+                record.ids = new Set();
+            }
+        }
+        return population;
+    }
+    getSummary(ShapesInfoList) {
+        const shapes = Object.create(null);
+        for (const population of ShapesInfoList) {
+            for (const key in population) {
+                shapes[key] = shapes[key] || {
+                    decrease: false,
+                    increase: false,
+                    counts: [],
+                    sizes: [],
+                    examples: [],
+                };
+                if (shapes[key].decrease) {
+                    continue;
+                }
+                const counts = shapes[key].counts;
+                const n = population[key].n;
+                if (counts.length > 0 && counts[counts.length - 1] > n) {
+                    shapes[key].decrease = true;
+                    continue;
+                }
+                if (counts.length > 0 && counts[counts.length - 1] < n) {
+                    shapes[key].increase = true;
+                }
+                counts.push(n);
+                shapes[key].sizes.push(population[key].size);
+                const examples = shapes[key].examples;
+                examples.push(population[key].examples[0]);
+            }
+        }
+        const result = [];
+        for (const key in shapes) {
+            if (!shapes[key].increase) {
+                continue;
+            }
+            if (shapes[key].decrease || shapes[key].counts.length <= 1) {
+                continue;
+            }
+            const counts = shapes[key].counts;
+            if (counts[counts.length - 1] < 1000) {
+                continue;
+            }
+            const examples = shapes[key].examples;
+            const sizes = shapes[key].sizes;
+            result.push({ shape: key, counts, examples, sizes });
+        }
+        result.sort((v1, v2) => v2.counts[v2.counts.length - 1] - v1.counts[v1.counts.length - 1]);
+        return result;
+    }
+    print(list) {
+        const colon = chalk_1.default.grey(': ');
+        const sep = chalk_1.default.grey(' > ');
+        const sep2 = chalk_1.default.grey(', ');
+        const dot = chalk_1.default.grey('· ');
+        for (const item of list) {
+            const shapeStat = [];
+            for (let i = 0; i < item.counts.length; ++i) {
+                let size = core_1.utils.getReadableBytes(item.sizes[i]);
+                size = chalk_1.default.grey(size);
+                shapeStat.push(`${item.counts[i]} (${size})`);
+            }
+            const countHistory = shapeStat.join(sep);
+            const examples = item.examples.map(v => `@${v}`).join(sep2);
+            const msg = `${dot}${item.shape}${colon}${countHistory}${colon}${examples}`;
+            core_1.info.topLevel(msg);
+        }
+    }
+}
+exports.default = ShapeUnboundGrowthAnalysis;

package/dist/plugins/StringAnalysis.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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
+ */
+import type { HeapAnalysisOptions } from '../PluginUtils';
+import { BaseOption } from '@memlab/core';
+import BaseAnalysis from '../BaseAnalysis';
+declare type StringRecord = {
+    n: number;
+    size: number;
+    ids: string[];
+    str?: string;
+};
+export default class StringAnalysis extends BaseAnalysis {
+    private topDupStrInCnt;
+    private topDupStrInCntListSize;
+    private topDupStrInSize;
+    private topDupStrInSizeListSize;
+    private stringPatternsStat;
+    getTopDuplicatedStringsInCount(): StringRecord[];
+    private static stringPatternsToObserve;
+    getCommandName(): string;
+    getDescription(): string;
+    getOptions(): BaseOption[];
+    private static shouldIgnoreNode;
+    process(options: HeapAnalysisOptions): Promise<void>;
+    private getPreprocessedStringMap;
+    private rankRecords;
+    private calculateTopDuplicatedStringsInCount;
+    private calculateTopDuplicatedStringsInSize;
+    private calculateStringPatternsStatistics;
+    private print;
+}
+export {};
+//# sourceMappingURL=StringAnalysis.d.ts.map

package/dist/plugins/StringAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringAnalysis.d.ts","sourceRoot":"","sources":["../../src/plugins/StringAnalysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAGxD,OAAO,EAAc,UAAU,EAAC,MAAM,cAAc,CAAC;AACrD,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAQ3C,aAAK,YAAY,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAiBF,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,YAAY;IACtD,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,sBAAsB,CAAM;IACpC,OAAO,CAAC,eAAe,CAAsB;IAC7C,OAAO,CAAC,uBAAuB,CAAM;IACrC,OAAO,CAAC,kBAAkB,CAAyB;IAE5C,8BAA8B,IAAI,YAAY,EAAE;IAMvD,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAmCpC;IAEK,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAI/B,UAAU,IAAI,UAAU,EAAE;IAI1B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAczB,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAU1D,OAAO,CAAC,wBAAwB;IAwBhC,OAAO,CAAC,WAAW;IA0BnB,OAAO,CAAC,oCAAoC;IAS5C,OAAO,CAAC,mCAAmC;IAS3C,OAAO,CAAC,iCAAiC;IA6BzC,OAAO,CAAC,KAAK;CA4Cd"}

package/dist/plugins/StringAnalysis.js

@@ -0,0 +1,217 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+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 chalk_1 = __importDefault(require("chalk"));
+const core_1 = require("@memlab/core");
+const BaseAnalysis_1 = __importDefault(require("../BaseAnalysis"));
+const PluginUtils_1 = __importDefault(require("../PluginUtils"));
+const HeapAnalysisSnapshotFileOption_1 = __importDefault(require("../options/HeapAnalysisSnapshotFileOption"));
+class StringAnalysis extends BaseAnalysis_1.default {
+    constructor() {
+        super(...arguments);
+        this.topDupStrInCnt = [];
+        this.topDupStrInCntListSize = 10;
+        this.topDupStrInSize = [];
+        this.topDupStrInSizeListSize = 10;
+        this.stringPatternsStat = {};
+    }
+    getTopDuplicatedStringsInCount() {
+        return this.topDupStrInCnt;
+    }
+    getCommandName() {
+        return 'string';
+    }
+    getDescription() {
+        return 'Analyze string in heap';
+    }
+    getOptions() {
+        return [new HeapAnalysisSnapshotFileOption_1.default()];
+    }
+    static shouldIgnoreNode(node) {
+        if (!core_1.utils.isStringNode(node) || core_1.utils.isSlicedStringNode(node)) {
+            return true;
+        }
+        // ignore strings retained by code
+        const dominators = core_1.utils.getAllDominators(node);
+        const hasCodeDominator = dominators.reduce((prev, cur) => prev && cur.type !== 'code', true);
+        return !hasCodeDominator;
+    }
+    process(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);
+            const stringMap = this.getPreprocessedStringMap(snapshot);
+            this.calculateStringPatternsStatistics(stringMap);
+            this.calculateTopDuplicatedStringsInCount(stringMap);
+            this.calculateTopDuplicatedStringsInSize(stringMap);
+            this.print();
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    getPreprocessedStringMap(snapshot) {
+        core_1.info.overwrite('building string map...');
+        const stringMap = Object.create(null);
+        // going through string nodes
+        snapshot.nodes.forEach((node) => {
+            if (StringAnalysis.shouldIgnoreNode(node)) {
+                return;
+            }
+            const strValue = core_1.utils.getStringNodeValue(node);
+            stringMap[strValue] = stringMap[strValue] || {
+                n: 0,
+                size: 0,
+                ids: [],
+            };
+            const record = stringMap[strValue];
+            ++record.n;
+            record.size += node.retainedSize;
+            record.ids.push(node.id);
+        });
+        return stringMap;
+    }
+    rankRecords(stringMap, compare, listSize) {
+        let rank = [];
+        for (const [str, record] of Object.entries(stringMap)) {
+            if (record.n <= 1) {
+                continue; // only care about duplicated strings
+            }
+            let i = 0;
+            for (i = rank.length - 1; i >= 0; --i) {
+                const item = rank[i];
+                if (compare(item, record) >= 0) {
+                    rank.splice(i + 1, 0, Object.assign({ str }, record));
+                    break;
+                }
+            }
+            if (i < 0) {
+                rank.unshift(Object.assign({ str }, record));
+            }
+            rank = rank.slice(0, listSize);
+        }
+        return rank;
+    }
+    calculateTopDuplicatedStringsInCount(stringMap) {
+        core_1.info.overwrite('calculating top duplicated strings in count...');
+        this.topDupStrInCnt = this.rankRecords(stringMap, (item1, item2) => item1.n - item2.n, this.topDupStrInCntListSize);
+    }
+    calculateTopDuplicatedStringsInSize(stringMap) {
+        core_1.info.overwrite('calculating top duplicated strings in size...');
+        this.topDupStrInSize = this.rankRecords(stringMap, (item1, item2) => item1.size - item2.size, this.topDupStrInSizeListSize);
+    }
+    calculateStringPatternsStatistics(stringMap) {
+        core_1.info.overwrite('calculating statistics for specified string patterns...');
+        const strPatternStat = Object.create(null);
+        for (const [str, record] of Object.entries(stringMap)) {
+            patternLoop: for (const [patternName, patternCheck] of Object.entries(StringAnalysis.stringPatternsToObserve)) {
+                if (!patternCheck(str)) {
+                    continue patternLoop;
+                }
+                strPatternStat[patternName] = strPatternStat[patternName] || {
+                    n: 0,
+                    dupN: 0,
+                    size: 0,
+                    dupSize: 0,
+                };
+                const item = strPatternStat[patternName];
+                item.n += record.n;
+                item.size += record.size;
+                if (record.n > 1) {
+                    item.dupN += record.n - 1;
+                    item.dupSize += (record.size * (record.n - 1)) / record.n;
+                }
+            }
+        }
+        this.stringPatternsStat = strPatternStat;
+    }
+    print() {
+        const sep = chalk_1.default.grey(', ');
+        const colon = chalk_1.default.grey(': ');
+        const beg = chalk_1.default.grey('[');
+        const end = chalk_1.default.grey(']');
+        const dot = chalk_1.default.grey('·');
+        const head = chalk_1.default.yellow.bind(chalk_1.default);
+        // print statistics of specified string patterns
+        for (const [str, item] of Object.entries(this.stringPatternsStat)) {
+            core_1.info.topLevel(head(`\n${str}`));
+            let p = core_1.utils.getReadablePercent(item.dupN / item.n);
+            core_1.info.topLevel(`${dot}Count: ${item.n} (${p} are duplicated)`);
+            const size = core_1.utils.getReadableBytes(item.size);
+            p = core_1.utils.getReadablePercent(item.dupSize / item.size);
+            core_1.info.topLevel(`${dot}Size: ${size} (${p} are duplicated)`);
+        }
+        core_1.info.topLevel(head('\nTop duplicated strings in count'));
+        for (let i = 0; i < this.topDupStrInCnt.length; ++i) {
+            const item = this.topDupStrInCnt[i];
+            const size = core_1.utils.getReadableBytes(item.size);
+            const str = `"${chalk_1.default.blue(item.str)}"`;
+            core_1.info.topLevel(` ${dot}${beg}${item.n}${sep}${size}${end}${colon}${str}`);
+        }
+        core_1.info.topLevel(head('\nTop duplicated strings in size:'));
+        for (let i = 0; i < this.topDupStrInSize.length; ++i) {
+            const item = this.topDupStrInSize[i];
+            const size = core_1.utils.getReadableBytes(item.size);
+            const str = `"${chalk_1.default.blue(item.str)}"`;
+            const exampleIds = item.ids.slice(0, 10).map((id) => `@${id}`);
+            let examples = exampleIds.join(', ');
+            if (exampleIds.length < item.ids.length) {
+                examples += ' ...';
+            }
+            examples = chalk_1.default.grey(examples);
+            core_1.info.topLevel(`\n ${dot}${beg}${size}${sep}${item.n}${end}${colon}${str}`);
+            core_1.info.topLevel(`    node examples: ${examples}`);
+        }
+    }
+}
+exports.default = StringAnalysis;
+// collect statistics for specified string patterns
+// pattern name -> string pattern checker
+StringAnalysis.stringPatternsToObserve = {
+    // all strings (excluding sliced strings)
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    'All strings': (_) => true,
+    'Relay DataID': (str) => {
+        return str.startsWith('Uzpf');
+    },
+    'Relay DataID composite': (str) => {
+        return /^\d+\{"/.test(str);
+    },
+    // example: "{"query_id":-7401558440803739294,"serialized":"z5_eJztfQ...
+    'Relay query': (str) => {
+        return str.startsWith('{"query_id":');
+    },
+    'Relay client string': (str) => {
+        return str.startsWith('client:');
+    },
+    // example: n00je7tq arfg74bv qs9ysxi8 k77z8yql i09qtzwb n7fi1qx3
+    'Element class name': (str) => {
+        const arr = str.split(' ');
+        if (arr.length < 6) {
+            return false;
+        }
+        for (const s of arr) {
+            if (s.length !== 8) {
+                return false;
+            }
+        }
+        return true;
+    },
+};

package/dist/plugins/UnmountedReactFiberNodesAnalysis.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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
+ */
+import type { HeapAnalysisOptions } from '../PluginUtils';
+import { BaseOption } from '@memlab/core';
+import BaseAnalysis from '../BaseAnalysis';
+export default class UnmountedFiberNodeAnalysis extends BaseAnalysis {
+    getCommandName(): string;
+    getDescription(): string;
+    getOptions(): BaseOption[];
+    process(options: HeapAnalysisOptions): Promise<void>;
+}
+//# sourceMappingURL=UnmountedReactFiberNodesAnalysis.d.ts.map

package/dist/plugins/UnmountedReactFiberNodesAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnmountedReactFiberNodesAnalysis.d.ts","sourceRoot":"","sources":["../../src/plugins/UnmountedReactFiberNodesAnalysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAQ,UAAU,EAAC,MAAM,cAAc,CAAC;AAE/C,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAG3C,MAAM,CAAC,OAAO,OAAO,0BAA2B,SAAQ,YAAY;IAClE,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,UAAU,IAAI,UAAU,EAAE;IAIpB,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ3D"}

package/dist/plugins/UnmountedReactFiberNodesAnalysis.js

@@ -0,0 +1,46 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+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 core_1 = require("@memlab/core");
+const HeapAnalysisSnapshotFileOption_1 = __importDefault(require("../options/HeapAnalysisSnapshotFileOption"));
+const BaseAnalysis_1 = __importDefault(require("../BaseAnalysis"));
+const PluginUtils_1 = __importDefault(require("../PluginUtils"));
+class UnmountedFiberNodeAnalysis extends BaseAnalysis_1.default {
+    getCommandName() {
+        return 'unmounted-fiber-node';
+    }
+    getDescription() {
+        return 'Get unmounted React Fiber nodes';
+    }
+    getOptions() {
+        return [new HeapAnalysisSnapshotFileOption_1.default()];
+    }
+    process(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);
+            const largeObjects = PluginUtils_1.default.filterOutLargestObjects(snapshot, core_1.utils.isDetachedFiberNode);
+            PluginUtils_1.default.printNodeListInTerminal(largeObjects);
+        });
+    }
+}
+exports.default = UnmountedFiberNodeAnalysis;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@memlab/heap-analysis",
+  "version": "1.0.0",
+  "description": "heap analysis plugins for memlab",
+  "keywords": [
+    "heap",
+    "analysis",
+    "plugin"
+  ],
+  "author": "Liang Gong <lgong@fb.com>",
+  "contributors": [],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@memlab/core": "^1.0.0",
+    "@memlab/e2e": "^1.0.0",
+    "ansi": "^0.3.1",
+    "babar": "^0.2.0",
+    "chalk": "^4.0.0",
+    "fs-extra": "^4.0.2",
+    "minimist": "^1.2.0",
+    "puppeteer": "^13.5.1",
+    "string-width": "^4.2.0",
+    "util.promisify": "^1.1.1",
+    "xvfb": "^0.4.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^9.0.3",
+    "@types/jest": "^27.4.1",
+    "@types/minimist": "^1.2.2",
+    "@types/node": "^12.16.3",
+    "@types/puppeteer": "^5.4.4",
+    "jest": "^27.5.1",
+    "ts-jest": "^27.1.4",
+    "typescript": "^4.6.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/facebookincubator/memlab.git",
+    "directory": "packages/heap-analysis"
+  },
+  "scripts": {
+    "build-pkg": "tsc",
+    "test-pkg": "jest .",
+    "clean-pkg": "rm -rf ./dist && rm -rf ./node_modules && rm -f ./tsconfig.tsbuildinfo"
+  },
+  "bugs": {
+    "url": "https://github.com/facebookincubator/memlab/issues"
+  },
+  "homepage": "https://github.com/facebookincubator/memlab#readme"
+}