@memlab/core 1.1.19 → 1.1.20

package/dist/__tests__/parser/StringNode.test.js

@@ -28,7 +28,7 @@ beforeEach(() => {
 });
 const timeout = 5 * 60 * 1000;
 test('String heap object APIs work', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f;
     class TestObject {
         constructor() {
             this.originalString = 'test';
@@ -44,6 +44,8 @@ test('String heap object APIs work', () => __awaiter(void 0, void 0, void 0, fun
     const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     const testObject = heap.getAnyObjectWithClassName('TestObject');
     expect(testObject).not.toBe(null);
+    // test the number of referrers getter
+    expect(testObject === null || testObject === void 0 ? void 0 : testObject.numOfReferrers).toBeGreaterThan(0);
     // testObject.originalString === 'test'
     const originalString = testObject === null || testObject === void 0 ? void 0 : testObject.getReferenceNode('originalString');
     expect(originalString === null || originalString === void 0 ? void 0 : originalString.isString).toBe(true);
@@ -58,4 +60,13 @@ test('String heap object APIs work', () => __awaiter(void 0, void 0, void 0, fun
     expect(complexConcatString === null || complexConcatString === void 0 ? void 0 : complexConcatString.type).toBe('concatenated string');
     expect(complexConcatString === null || complexConcatString === void 0 ? void 0 : complexConcatString.isString).toBe(true);
     expect((_c = complexConcatString === null || complexConcatString === void 0 ? void 0 : complexConcatString.toStringNode()) === null || _c === void 0 ? void 0 : _c.stringValue).toBe('prefix_value_123_suffix');
+    // test the toJSONString API
+    let strRepresentation = (_d = concatString === null || concatString === void 0 ? void 0 : concatString.toJSONString()) !== null && _d !== void 0 ? _d : '{}';
+    let rep = JSON.parse(strRepresentation);
+    expect(rep.type).toBe('concatenated string');
+    expect(rep.stringValue).toBe(undefined);
+    strRepresentation = (_f = (_e = concatString === null || concatString === void 0 ? void 0 : concatString.toStringNode()) === null || _e === void 0 ? void 0 : _e.toJSONString()) !== null && _f !== void 0 ? _f : '{}';
+    rep = JSON.parse(strRepresentation);
+    expect(rep.type).toBe('concatenated string');
+    expect(rep.stringValue).toBe('prefix_suffix');
 }), timeout);

package/dist/lib/Config.d.ts

@@ -196,6 +196,8 @@ export declare class MemLabConfig {
     seqClusteringIsRandomChunks: boolean;
     instrumentJS: boolean;
     interceptScript: boolean;
+    isAnalyzingMainThread: boolean;
+    targetWorkerTitle: Nullable<string>;
     constructor(options?: ConfigOption);
     private initInternalConfigs;
     private init;

package/dist/lib/Config.js

@@ -211,6 +211,10 @@ class MemLabConfig {
         this.isManualDebug = false;
         // number of warmup repeat in each browser tab instance
         this.warmupRepeat = 2;
+        // by default, analyzing heap in main thread
+        this.isAnalyzingMainThread = true;
+        // target worker's title
+        this.targetWorkerTitle = null;
         // default waiting time when there is no page load checker callback
         this.delayWhenNoPageLoadCheck = 2000;
         // repeat the intermediate sequence

package/dist/lib/FileManager.d.ts

@@ -51,7 +51,9 @@ export declare class FileManager {
     getPreviewReportDir(options?: FileOption): string;
     getLeakSummaryFile(options?: FileOption): string;
     getRunMetaFile(options?: FileOption): string;
+    getRunMetaExternalTemplateFile(): string;
     getSnapshotSequenceMetaFile(options?: FileOption): string;
+    getSnapshotSequenceExternalTemplateFile(): string;
     getInputDataDir(): string;
     getAllFilesInSubDirs(dir: string): string[];
     getTmpDir(): string;
@@ -72,6 +74,7 @@ export declare class FileManager {
     iterateAllFiles(dir: string, callback: (filepath: string) => AnyValue): void;
     rmWorkDir(options?: FileOption): void;
     isWithinInternalDirectory(filePath: string): boolean;
+    createDefaultVisitOrderMetaFile(options?: FileOption): void;
     initDirs(config: MemLabConfig, options?: FileOption): void;
 }
 declare const _default: FileManager;

package/dist/lib/FileManager.js

@@ -179,9 +179,15 @@ class FileManager {
     getRunMetaFile(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getCurDataDir(options), 'run-meta.json');
     }
+    getRunMetaExternalTemplateFile() {
+        return path_1.default.join(this.getCodeDataDir(), 'run-meta.json');
+    }
     getSnapshotSequenceMetaFile(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getCurDataDir(options), 'snap-seq.json');
     }
+    getSnapshotSequenceExternalTemplateFile() {
+        return path_1.default.join(this.getCodeDataDir(), 'visit-order.json');
+    }
     getInputDataDir() {
         return path_1.default.join(this.getDefaultWorkDir(), 'input');
     }
@@ -331,6 +337,37 @@ class FileManager {
         const internalDir = Constant_1.default.internalDir;
         return filePath.includes(`${sep}${internalDir}${sep}`);
     }
+    createDefaultVisitOrderMetaFile(options = FileManager.defaultFileOption) {
+        // if memlab/data/cur doesn't exist, return
+        const curDataDir = this.getCurDataDir(options);
+        if (!fs_extra_1.default.existsSync(curDataDir)) {
+            return;
+        }
+        // if the snap-seq.json file exists, return
+        const snapshotSeqMetaFile = this.getSnapshotSequenceMetaFile(options);
+        if (fs_extra_1.default.existsSync(snapshotSeqMetaFile)) {
+            return;
+        }
+        // if there is no .heapsnapshot file, return
+        const files = fs_extra_1.default.readdirSync(curDataDir);
+        const snapshotFile = files.find(file => file.endsWith('.heapsnapshot'));
+        if (snapshotFile == null) {
+            return;
+        }
+        // If there is at least one snapshot, create a snap-seq.json file.
+        // First, get the meta file for leak detection in a single heap snapshot
+        const codeDataDir = this.getCodeDataDir();
+        const singleSnapshotMetaFile = path_1.default.join(codeDataDir, 'visit-order-single-snapshot.json');
+        const visitOrder = JSON.parse(fs_extra_1.default.readFileSync(singleSnapshotMetaFile, 'UTF-8'));
+        // fill in snapshot file name for each entry with snapshot: true
+        visitOrder.forEach(step => {
+            if (step.snapshot === true) {
+                step.snapshotFile = snapshotFile;
+            }
+        });
+        // save the snapshot meta file
+        fs_extra_1.default.writeFileSync(snapshotSeqMetaFile, JSON.stringify(visitOrder, null, 2), 'UTF-8');
+    }
     initDirs(config, options = FileManager.defaultFileOption) {
         // cache the last processed memlab config instance
         // the instance should be a singleton
@@ -339,6 +376,11 @@ class FileManager {
         // make sure getWorkDir is called first before
         // any other get file or get dir calls
         const workDir = this.getWorkDir(options);
+        // if errorWhenAbsent is set to true, make it
+        // an error when the working directory does not exist
+        if (options.errorWhenAbsent && !fs_extra_1.default.existsSync(workDir)) {
+            throw Utils_1.default.haltOrThrow(`work dir does not exist: ${workDir}`);
+        }
         // remember the current working directory
         // especially if this is a transcient working directory
         config.workDir = joinAndProcessDir(options, workDir);
@@ -376,15 +418,16 @@ class FileManager {
         config.heapAnalysisLogDir = joinAndProcessDir(options, this.getHeapAnalysisLogDir(options));
         config.metricsOutDir = joinAndProcessDir(options, loggerOutDir, 'metrics');
         config.reportScreenshotFile = path_1.default.join(outDir, 'report.png');
-        const codeDataDir = this.getCodeDataDir();
-        config.externalRunMetaFile = path_1.default.join(codeDataDir, 'run-meta.json');
-        config.externalSnapshotVisitOrderFile = path_1.default.join(codeDataDir, 'visit-order.json');
+        config.externalRunMetaFile = this.getRunMetaExternalTemplateFile();
+        config.externalSnapshotVisitOrderFile =
+            this.getSnapshotSequenceExternalTemplateFile();
         joinAndProcessDir(options, this.getUniqueTraceClusterDir(options));
         config.newUniqueClusterDir = joinAndProcessDir(options, this.getNewUniqueTraceClusterDir(options));
         config.staleUniqueClusterDir = joinAndProcessDir(options, this.getStaleUniqueTraceClusterDir(options));
         config.currentUniqueClusterDir = joinAndProcessDir(options, this.getExistingUniqueTraceClusterDir(options));
         config.unclassifiedClusterDir = joinAndProcessDir(options, this.getUnclassifiedTraceClusterDir(options));
         config.allClusterSummaryFile = this.getAllClusterSummaryFile(options);
+        this.createDefaultVisitOrderMetaFile(options);
     }
 }
 exports.FileManager = FileManager;

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 = {
@@ -897,6 +898,7 @@ export interface IE2EStepBasic {
 /** @internal */
 export declare type E2EStepInfo = IE2EStepBasic & {
     snapshot: boolean;
+    snapshotFile?: string;
     screenshot: boolean;
     idx: number;
     JSHeapUsedSize: number;
@@ -1218,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 {
@@ -1290,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
@@ -1446,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.
@@ -1493,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)
@@ -1563,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)
@@ -1580,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.

package/dist/lib/Utils.d.ts

@@ -125,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;
@@ -149,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);
@@ -1347,6 +1347,9 @@ function getSingleSnapshotFileForAnalysis() {
     return resolveSnapshotFilePath(path);
 }
 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);
@@ -1790,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);
@@ -1799,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,
@@ -1822,7 +1846,9 @@ exports.default = {
     getEdgeByNameAndType,
     getLastNodeId,
     getLeakedNode,
+    getLeakTracePathLength,
     getNodesIdSet,
+    getNumberAtPercentile,
     getNumberNodeValue,
     getReadableBytes,
     getReadablePercent,

package/dist/lib/charts/MemoryBarChart.js

@@ -30,6 +30,12 @@ class MemoryBarChart {
             Console_1.default.warning(`plot data not load correctly: ${Utils_1.default.getError(ex).message}`);
             return;
         }
+        if (plotData.length === 0) {
+            if (Config_1.default.verbose) {
+                Console_1.default.warning('no memory usage data to plot');
+            }
+            return;
+        }
         // normalize plot data
         const minY = 1;
         const maxY = plotData.reduce((m, v) => Math.max(m, v[1]), 0) * 1.15;

package/dist/lib/heap-data/HeapEdge.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapEdge } from '../Types';
+import type { AnyRecord, AnyValue, IHeapEdge } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 import HeapNode from './HeapNode';
 export default class HeapEdge implements IHeapEdge {
@@ -23,5 +23,7 @@ export default class HeapEdge implements IHeapEdge {
     get to_node(): number;
     get toNode(): HeapNode;
     get fromNode(): HeapNode;
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
 }
 //# sourceMappingURL=HeapEdge.d.ts.map

package/dist/lib/heap-data/HeapEdge.js

@@ -71,5 +71,18 @@ class HeapEdge {
         const srcNodeIdx = edgeIndex2SrcNodeIndex[this.idx];
         return new HeapNode_1.default(heapSnapshot, srcNodeIdx);
     }
+    getJSONifyableObject() {
+        return {
+            name_or_index: this.name_or_index,
+            type: this.type,
+            edgeIndex: this.edgeIndex,
+            toNode: this.toNode.getJSONifyableObject(),
+            fromNode: this.fromNode.getJSONifyableObject(),
+        };
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
 }
 exports.default = HeapEdge;

package/dist/lib/heap-data/HeapLocation.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapLocation, IHeapNode, Nullable } from '../Types';
+import type { AnyRecord, AnyValue, IHeapLocation, IHeapNode, Nullable } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 export default class HeapLocation implements IHeapLocation {
     private heapSnapshot;
@@ -19,5 +19,7 @@ export default class HeapLocation implements IHeapLocation {
     get script_id(): number;
     get line(): number;
     get column(): number;
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
 }
 //# sourceMappingURL=HeapLocation.d.ts.map

package/dist/lib/heap-data/HeapLocation.js

@@ -43,5 +43,19 @@ class HeapLocation {
         const locationFieldsCount = heapSnapshot._locationFieldsCount;
         return locations[this.idx * locationFieldsCount + heapSnapshot._locationColumnOffset];
     }
+    getJSONifyableObject() {
+        const node = this.node;
+        const jsonNode = node == null ? null : node.getJSONifyableObject();
+        return {
+            node: jsonNode,
+            script_id: this.script_id,
+            line: this.line,
+            column: this.column,
+        };
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
 }
 exports.default = HeapLocation;

package/dist/lib/heap-data/HeapNode.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapNode, IHeapEdge, Nullable, EdgeIterationCallback, Predicator, IHeapStringNode } from '../Types';
+import type { IHeapNode, IHeapEdge, Nullable, EdgeIterationCallback, Predicator, IHeapStringNode, AnyRecord, AnyValue } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 import HeapEdge from './HeapEdge';
 import HeapLocation from './HeapLocation';
@@ -33,8 +33,11 @@ export default class HeapNode implements IHeapNode {
     forEachReference(callback: EdgeIterationCallback): void;
     findAnyReference(predicate: Predicator<IHeapEdge>): Nullable<IHeapEdge>;
     findAnyReferrer(predicate: Predicator<IHeapEdge>): Nullable<IHeapEdge>;
+    findAnyReferrerNode(predicate: Predicator<IHeapNode>): Nullable<IHeapNode>;
     findReferrers(predicate: Predicator<IHeapEdge>): IHeapEdge[];
+    findReferrerNodes(predicate: Predicator<IHeapNode>): IHeapNode[];
     get referrers(): HeapEdge[];
+    get numOfReferrers(): number;
     forEachReferrer(callback: EdgeIterationCallback): void;
     get hasPathEdge(): boolean;
     get pathEdge(): Nullable<HeapEdge>;
@@ -53,5 +56,7 @@ export default class HeapNode implements IHeapNode {
     getReferrerNodes(edgeName: string | number, edgeType?: string): IHeapNode[];
     get isString(): boolean;
     toStringNode(): Nullable<IHeapStringNode>;
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
 }
 //# sourceMappingURL=HeapNode.d.ts.map

package/dist/lib/heap-data/HeapNode.js

@@ -151,6 +151,17 @@ class HeapNode {
         });
         return found;
     }
+    findAnyReferrerNode(predicate) {
+        let found = null;
+        this.forEachReferrer((edge) => {
+            const node = edge.fromNode;
+            if (predicate(node)) {
+                found = node;
+                return { stop: true };
+            }
+        });
+        return found;
+    }
     findReferrers(predicate) {
         const ret = [];
         this.forEachReferrer((edge) => {
@@ -161,6 +172,17 @@ class HeapNode {
         });
         return ret;
     }
+    findReferrerNodes(predicate) {
+        const ret = [];
+        this.forEachReferrer((edge) => {
+            const node = edge.fromNode;
+            if (predicate(node)) {
+                ret.push(node);
+            }
+            return null;
+        });
+        return ret;
+    }
     get referrers() {
         const heapSnapshot = this.heapSnapshot;
         const retainingEdgeIndex2EdgeIndex = heapSnapshot._retainingEdgeIndex2EdgeIndex;
@@ -174,6 +196,13 @@ class HeapNode {
         }
         return ret;
     }
+    get numOfReferrers() {
+        const heapSnapshot = this.heapSnapshot;
+        const firstRetainerIndex = heapSnapshot._firstRetainerIndex;
+        const beginIdx = firstRetainerIndex[this.idx];
+        const endIdx = firstRetainerIndex[this.idx + 1];
+        return endIdx - beginIdx;
+    }
     forEachReferrer(callback) {
         const heapSnapshot = this.heapSnapshot;
         const retainingEdgeIndex2EdgeIndex = heapSnapshot._retainingEdgeIndex2EdgeIndex;
@@ -342,6 +371,23 @@ class HeapNode {
             ? new HeapStringNode_1.default(this.heapSnapshot, this.idx)
             : null;
     }
+    getJSONifyableObject() {
+        return {
+            id: this.id,
+            name: this.name,
+            type: this.type,
+            self_size: this.self_size,
+            trace_node_id: this.trace_node_id,
+            nodeIndex: this.nodeIndex,
+            outGoingEdgeCount: this.edge_count,
+            incomingEdgeCount: this.numOfReferrers,
+            contructorName: this.constructor.name,
+        };
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
 }
 exports.default = HeapNode;
 // HeapStringNode has to be imported after exporting HeapNode

package/dist/lib/heap-data/HeapSnapshot.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapNode, IHeapNodes, IHeapEdges, IHeapSnapshot, HeapNodeTypes, HeapEdgeTypes, HeapSnapshotMeta, RawHeapSnapshot, NumericDictionary, Nullable } from '../Types';
+import type { AnyRecord, AnyValue, IHeapNode, IHeapNodes, IHeapEdges, IHeapSnapshot, HeapNodeTypes, HeapEdgeTypes, HeapSnapshotMeta, RawHeapSnapshot, NumericDictionary, Nullable } from '../Types';
 import HeapNode from './HeapNode';
 export default class HeapSnapshot implements IHeapSnapshot {
     snapshot: RawHeapSnapshot;
@@ -67,6 +67,8 @@ export default class HeapSnapshot implements IHeapSnapshot {
     _firstRetainerIndex: Uint32Array;
     _edgeIndex2SrcNodeIndex: Uint32Array;
     constructor(snapshot: RawHeapSnapshot, _options?: Record<string, never>);
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
     hasObjectWithClassName(className: string): boolean;
     getAnyObjectWithClassName(className: string): Nullable<IHeapNode>;
     hasObjectWithPropertyName(nameOrIndex: string | number): boolean;

package/dist/lib/heap-data/HeapSnapshot.js

@@ -129,6 +129,13 @@ class HeapSnapshot {
             },
         };
     }
+    getJSONifyableObject() {
+        return Object.assign({}, this.snapshot.snapshot);
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
     hasObjectWithClassName(className) {
         let detected = false;
         this.nodes.forEach((node) => {

package/dist/lib/heap-data/HeapStringNode.d.ts

@@ -8,11 +8,12 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapStringNode } from '../Types';
+import type { AnyRecord, IHeapStringNode } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 import HeapNode from './HeapNode';
 export default class HeapStringNode extends HeapNode implements IHeapStringNode {
     constructor(heapSnapshot: HeapSnapshot, idx: number);
     get stringValue(): string;
+    getJSONifyableObject(): AnyRecord;
 }
 //# sourceMappingURL=HeapStringNode.d.ts.map

package/dist/lib/heap-data/HeapStringNode.js

@@ -41,5 +41,10 @@ class HeapStringNode extends HeapNode_1.default {
         }
         return this.name;
     }
+    getJSONifyableObject() {
+        const rep = super.getJSONifyableObject();
+        rep.stringValue = this.stringValue;
+        return rep;
+    }
 }
 exports.default = HeapStringNode;

package/dist/trace-cluster/TraceBucket.d.ts

@@ -24,6 +24,7 @@ export default class NormalizedTrace {
     getTraceSummary(): string;
     static addLeakedNodeToCluster(cluster: TraceCluster, path: LeakTracePathItem): void;
     static calculateClusterRetainedSize(cluster: TraceCluster, snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb): number;
+    static getSamplePathMaxLength(paths: LeakTracePathItem[]): number;
     static samplePaths(paths: LeakTracePathItem[]): LeakTracePathItem[];
     private static diffTraces;
     static diffClusters(newClusters: TraceCluster[], existingClusters: TraceCluster[]): TraceClusterDiff;

package/dist/trace-cluster/TraceBucket.js

@@ -122,16 +122,30 @@ class NormalizedTrace {
         }
         return (cluster.retainedSize = aggregateDominatorMetrics(cluster.leakedNodeIds, snapshot, () => true, (node) => node.retainedSize));
     }
+    static getSamplePathMaxLength(paths) {
+        const lengthArr = paths.map(p => Utils_1.default.getLeakTracePathLength(p));
+        return Math.max(30, Utils_1.default.getNumberAtPercentile(lengthArr, 80));
+    }
     static samplePaths(paths) {
         const maxCount = 5000;
+        if (paths.length <= maxCount) {
+            return [...paths];
+        }
         const sampleRatio = Math.min(1, maxCount / paths.length);
         if (sampleRatio < 1) {
             Console_1.default.warning('Sampling trace due to a large number of traces:');
             Console_1.default.lowLevel(` Number of Traces: ${paths.length}`);
-            Console_1.default.lowLevel(` Sampling Ratio:   ${Utils_1.default.getReadablePercent(sampleRatio)}`);
+            Console_1.default.lowLevel(` Sampling Ratio: ${Utils_1.default.getReadablePercent(sampleRatio)}`);
         }
         const ret = [];
+        const samplePathMaxLength = NormalizedTrace.getSamplePathMaxLength(paths);
+        if (Config_1.default.verbose) {
+            Console_1.default.lowLevel(` Sample Trace's Max Length: ${samplePathMaxLength}`);
+        }
         for (const p of paths) {
+            if (Utils_1.default.getLeakTracePathLength(p) > samplePathMaxLength) {
+                continue;
+            }
             if (Math.random() < sampleRatio) {
                 ret.push(p);
             }

package/dist/trace-cluster/TraceElement.d.ts

@@ -7,7 +7,7 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { EdgeIterationCallback, IHeapEdge, IHeapLocation, IHeapNode, IHeapSnapshot, IHeapStringNode, Nullable } from '../lib/Types';
+import type { AnyValue, EdgeIterationCallback, IHeapEdge, IHeapLocation, IHeapNode, IHeapSnapshot, IHeapStringNode, Nullable } from '../lib/Types';
 export declare class NodeRecord implements IHeapNode {
     kind: string;
     name: string;
@@ -32,11 +32,14 @@ export declare class NodeRecord implements IHeapNode {
     forEachReference(_callback: EdgeIterationCallback): void;
     set referrers(r: IHeapEdge[]);
     get referrers(): IHeapEdge[];
+    get numOfReferrers(): number;
     toStringNode(): IHeapStringNode;
     forEachReferrer(_callback: EdgeIterationCallback): void;
     findAnyReference(): Nullable<IHeapEdge>;
     findAnyReferrer(): Nullable<IHeapEdge>;
+    findAnyReferrerNode(): Nullable<IHeapNode>;
     findReferrers(): IHeapEdge[];
+    findReferrerNodes(): IHeapNode[];
     set hasPathEdge(f: boolean);
     get hasPathEdge(): boolean;
     set pathEdge(r: IHeapEdge);
@@ -51,6 +54,7 @@ export declare class NodeRecord implements IHeapNode {
     getAnyReferrerNode(_edgeName: string | number, _edgeType?: string): Nullable<IHeapNode>;
     getReferrers(_edgeName: string | number, _edgeType?: string): IHeapEdge[];
     getReferrerNodes(_edgeName: string | number, _edgeType?: string): IHeapNode[];
+    toJSONString(...args: Array<AnyValue>): string;
     constructor(node: IHeapNode);
     private extraceNodeName;
 }
@@ -62,6 +66,7 @@ export declare class EdgeRecord implements IHeapEdge {
     is_index: boolean;
     to_node: number;
     constructor(edge: IHeapEdge);
+    toJSONString(...args: Array<AnyValue>): string;
     set snapshot(s: IHeapSnapshot);
     get snapshot(): IHeapSnapshot;
     set toNode(s: IHeapNode);

package/dist/trace-cluster/TraceElement.js

@@ -62,6 +62,9 @@ class NodeRecord {
     get referrers() {
         throw new Error('NodeRecord.referrers cannot be read');
     }
+    get numOfReferrers() {
+        throw new Error('NodeRecord.numOfReferrers cannot be read');
+    }
     toStringNode() {
         throw new Error('NodeRecord.toStringNode is not implemented');
     }
@@ -76,9 +79,15 @@ class NodeRecord {
     findAnyReferrer() {
         throw new Error('NodeRecord.findAnyReferrer is not implemented');
     }
+    findAnyReferrerNode() {
+        throw new Error('NodeRecord.findAnyReferrerNode is not implemented');
+    }
     findReferrers() {
         throw new Error('NodeRecord.findReferrers is not implemented');
     }
+    findReferrerNodes() {
+        throw new Error('NodeRecord.findReferrerNodes is not implemented');
+    }
     set hasPathEdge(f) {
         throw new Error('NodeRecord.hasPathEdge cannot be assigned');
     }
@@ -145,6 +154,20 @@ class NodeRecord {
     _edgeType) {
         throw new Error('NodeRecord.getReferrerNodes is not implemented');
     }
+    toJSONString(...args) {
+        const rep = {
+            id: this.id,
+            kind: this.kind,
+            name: this.name,
+            type: this.type,
+            self_size: this.self_size,
+            trace_node_id: this.trace_node_id,
+            nodeIndex: this.nodeIndex,
+            incomingEdgeCount: this.numOfReferrers,
+            contructorName: this.constructor.name,
+        };
+        return JSON.stringify(rep, ...args);
+    }
     extraceNodeName(node) {
         // deserialized node may not have snapshot info
         if (!node.snapshot || !Utils_1.default.isFiberNode(node)) {
@@ -163,6 +186,16 @@ class EdgeRecord {
         this.is_index = edge.is_index;
         this.to_node = edge.to_node;
     }
+    toJSONString(...args) {
+        const rep = {
+            kind: this.kind,
+            name_or_index: this.name_or_index,
+            type: this.type,
+            edgeIndex: this.edgeIndex,
+            to_node: this.to_node,
+        };
+        return JSON.stringify(rep, ...args);
+    }
     set snapshot(s) {
         throw new Error('EdgeRecord.snapshot cannot be assigned.');
     }

package/dist/trace-cluster/strategies/TraceSimilarityStrategy.js

@@ -12,6 +12,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const Config_1 = __importDefault(require("../../lib/Config"));
+const Console_1 = __importDefault(require("../../lib/Console"));
 const ClusterUtils_1 = __importDefault(require("../ClusterUtils"));
 // cluster by putting similar traces together
 class TraceSimilarityStrategy {
@@ -41,6 +43,13 @@ class TraceSimilarityStrategy {
         // checking new clusters
         outer: for (let i = 0; i < newTraces.length; ++i) {
             const traceToCheck = newTraces[i];
+            // use an odd number as the divider. If we choose 10 as the divider,
+            // when updating the progress indicator, the final digit always ends
+            // with a zero, which can appear strange and not representative of
+            // the actual progress.
+            if (!Config_1.default.isContinuousTest && i % 17 === 0) {
+                Console_1.default.overwrite(`clustering trace: ${i} / ${newTraces.length}`);
+            }
             for (let j = 0; j < clusters.length; ++j) {
                 const repTrace = clusters[j][0];
                 if (TraceSimilarityStrategy.isSimilarTrace(repTrace, traceToCheck)) {

package/package.json

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

package/static/visit-order-single-snapshot.json

@@ -0,0 +1,19 @@
+[
+  {
+    "name": "target",
+    "url": "",
+    "snapshot": true,
+    "screenshot": false,
+    "type": "target",
+    "idx": 1
+  },
+  {
+    "name": "final",
+    "url": "",
+    "delay": 10000,
+    "snapshot": true,
+    "screenshot": false,
+    "type": "final",
+    "idx": 2
+  }
+]