@memlab/core 1.1.18 → 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/index.d.ts

@@ -7,11 +7,11 @@
  * @format
  * @oncall web_perf_infra
  */
-/** @internal */
-export declare function registerPackage(): Promise<void>;
 export * from './lib/Types';
 export * from './lib/NodeHeap';
 /** @internal */
+export declare function registerPackage(): Promise<void>;
+/** @internal */
 export { default as config } from './lib/Config';
 /** @internal */
 export * from './lib/InternalValueSetter';
@@ -36,6 +36,8 @@ export { default as analysis } from './lib/HeapAnalyzer';
 /** @internal */
 export { default as constant } from './lib/Constant';
 /** @internal */
+export { default as memoryBarChart } from './lib/charts/MemoryBarChart';
+/** @internal */
 export { default as modes } from './modes/RunningModes';
 /** @internal */
 export { default as ProcessManager } from './lib/ProcessManager';

package/dist/index.js

@@ -35,9 +35,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TraceFinder = exports.MultiIterationSeqClustering = exports.SequentialClustering = exports.EvaluationMetric = exports.NormalizedTrace = exports.leakClusterLogger = exports.ProcessManager = exports.modes = exports.constant = exports.analysis = exports.browserInfo = exports.serializer = exports.fileManager = exports.utils = exports.BaseOption = exports.info = exports.config = exports.registerPackage = void 0;
+exports.TraceFinder = exports.MultiIterationSeqClustering = exports.SequentialClustering = exports.EvaluationMetric = exports.NormalizedTrace = exports.leakClusterLogger = exports.ProcessManager = exports.modes = exports.memoryBarChart = exports.constant = exports.analysis = exports.browserInfo = exports.serializer = exports.fileManager = exports.utils = exports.BaseOption = exports.info = exports.config = exports.registerPackage = void 0;
 const path_1 = __importDefault(require("path"));
 const PackageInfoLoader_1 = require("./lib/PackageInfoLoader");
+__exportStar(require("./lib/Types"), exports);
+__exportStar(require("./lib/NodeHeap"), exports);
 /** @internal */
 function registerPackage() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -45,8 +47,6 @@ function registerPackage() {
     });
 }
 exports.registerPackage = registerPackage;
-__exportStar(require("./lib/Types"), exports);
-__exportStar(require("./lib/NodeHeap"), exports);
 /** @internal */
 var Config_1 = require("./lib/Config");
 Object.defineProperty(exports, "config", { enumerable: true, get: function () { return __importDefault(Config_1).default; } });
@@ -81,6 +81,9 @@ Object.defineProperty(exports, "analysis", { enumerable: true, get: function ()
 var Constant_1 = require("./lib/Constant");
 Object.defineProperty(exports, "constant", { enumerable: true, get: function () { return __importDefault(Constant_1).default; } });
 /** @internal */
+var MemoryBarChart_1 = require("./lib/charts/MemoryBarChart");
+Object.defineProperty(exports, "memoryBarChart", { enumerable: true, get: function () { return __importDefault(MemoryBarChart_1).default; } });
+/** @internal */
 var RunningModes_1 = require("./modes/RunningModes");
 Object.defineProperty(exports, "modes", { enumerable: true, get: function () { return __importDefault(RunningModes_1).default; } });
 /** @internal */

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

@@ -11,6 +11,7 @@ import type { MemLabConfig } from './Config';
 import type { AnyValue, FileOption } from './Types';
 /** @internal */
 export declare class FileManager {
+    private memlabConfigCache;
     getDefaultWorkDir(): string;
     generateTmpHeapDir(): string;
     private static transientInstanceIdx;
@@ -50,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;
@@ -63,6 +66,7 @@ export declare class FileManager {
     initNewHeapAnalysisLogFile(options?: FileOption): string;
     getAndInitTSCompileIntermediateDir(): string;
     clearDataDirs(options?: FileOption): void;
+    removeSnapshotFiles(options?: FileOption): void;
     emptyDirIfExists(dir: string): void;
     emptyTraceLogDataDir(options?: FileOption): void;
     resetBrowserDir(): void;
@@ -70,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

@@ -13,7 +13,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileManager = void 0;
-const minimist_1 = __importDefault(require("minimist"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
@@ -37,6 +36,9 @@ function joinAndProcessDir(options, ...args) {
 }
 /** @internal */
 class FileManager {
+    constructor() {
+        this.memlabConfigCache = null;
+    }
     getDefaultWorkDir() {
         return path_1.default.join(this.getTmpDir(), 'memlab');
     }
@@ -48,11 +50,12 @@ class FileManager {
         return dirPath;
     }
     getWorkDir(options = FileManager.defaultFileOption) {
+        var _a;
         // workDir options supercedes all the other options
         if (options.workDir) {
             return path_1.default.resolve(options.workDir);
         }
-        // transient options supercedes other the CLI options
+        // transient options supercedes the other CLI options
         if (options.transient) {
             const idx = ++FileManager.transientInstanceIdx;
             const instanceId = `${process.pid}-${Date.now()}-${idx}`;
@@ -60,8 +63,11 @@ class FileManager {
             return path_1.default.resolve(workDir);
         }
         // workDir from the CLI options
-        const argv = (0, minimist_1.default)(process.argv.slice(2));
-        const workDir = argv['work-dir'] || this.getDefaultWorkDir();
+        const workDir = FileManager.defaultFileOption.workDir ||
+            (
+            // in case there is a transcient working directory generated
+            (_a = this.memlabConfigCache) === null || _a === void 0 ? void 0 : _a.workDir) ||
+            this.getDefaultWorkDir();
         return path_1.default.resolve(workDir);
     }
     getChromeBinaryZipFile() {
@@ -173,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');
     }
@@ -249,6 +261,23 @@ class FileManager {
             }
         }
     }
+    removeSnapshotFiles(options = FileManager.defaultFileOption) {
+        const curDataDir = this.getCurDataDir(options);
+        if (!fs_extra_1.default.existsSync(curDataDir)) {
+            return;
+        }
+        const dataSuffix = ['.heapsnapshot'];
+        const files = fs_extra_1.default.readdirSync(curDataDir);
+        for (const file of files) {
+            inner: for (const suffix of dataSuffix) {
+                if (file.endsWith(suffix)) {
+                    const filepath = path_1.default.join(curDataDir, file);
+                    fs_extra_1.default.unlinkSync(filepath);
+                    break inner;
+                }
+            }
+        }
+    }
     emptyDirIfExists(dir) {
         if (this.isDirectory(dir)) {
             fs_extra_1.default.emptyDirSync(dir);
@@ -308,11 +337,52 @@ 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
+        this.memlabConfigCache = config;
         config.monoRepoDir = Constant_1.default.monoRepoDir;
         // 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);
         options = Object.assign(Object.assign({}, options), { workDir });
         config.dataBaseDir = joinAndProcessDir(options, this.getDataBaseDir(options));
@@ -348,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/HeapAnalyzer.d.ts

@@ -7,17 +7,25 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { E2EStepInfo, HeapNodeIdSet, IHeapSnapshot, IMemoryAnalystOptions, IMemoryAnalystSnapshotDiff, IOveralHeapInfo, LeakTracePathItem, Optional, IOveralLeakInfo, TraceCluster, ISerializedInfo } from './Types';
+import type { E2EStepInfo, HeapNodeIdSet, IHeapSnapshot, IMemoryAnalystSnapshotDiff, IOveralHeapInfo, LeakTracePathItem, Optional, IOveralLeakInfo, TraceCluster, ISerializedInfo, DiffLeakOptions } from './Types';
 import TraceFinder from '../paths/TraceFinder';
+declare type DiffSnapshotsOptions = {
+    loadAllSnapshots?: boolean;
+    workDir?: string;
+};
+declare type WorkDirOptions = {
+    workDir?: string;
+};
 declare class MemoryAnalyst {
     checkLeak(): Promise<ISerializedInfo[]>;
+    diffLeakByWorkDir(options: DiffLeakOptions): Promise<ISerializedInfo[]>;
+    diffMemoryLeakTraces(options: DiffLeakOptions): Promise<ISerializedInfo[]>;
     detectMemoryLeaks(): Promise<ISerializedInfo[]>;
-    visualizeMemoryUsage(options?: IMemoryAnalystOptions): void;
     focus(options?: {
         file?: string;
     }): Promise<void>;
     shouldLoadCompleteSnapshot(tabsOrder: E2EStepInfo[], tab: E2EStepInfo): boolean;
-    diffSnapshots(loadAll?: boolean): Promise<IMemoryAnalystSnapshotDiff>;
+    diffSnapshots(options?: DiffSnapshotsOptions): Promise<IMemoryAnalystSnapshotDiff>;
     preparePathFinder(snapshot: IHeapSnapshot): TraceFinder;
     private dumpPageInteractionSummary;
     private dumpLeakSummaryToConsole;
@@ -29,12 +37,11 @@ declare class MemoryAnalyst {
     printHeapInfo(leakInfo: IOveralHeapInfo): void;
     private printHeapAndLeakInfo;
     private logLeakTraceSummary;
-    searchLeakedTraces(leakedNodeIds: HeapNodeIdSet, snapshot: IHeapSnapshot): Promise<{
-        paths: LeakTracePathItem[];
-    }>;
+    filterLeakPaths(leakedNodeIds: HeapNodeIdSet, snapshot: IHeapSnapshot, options?: WorkDirOptions): LeakTracePathItem[];
+    findLeakTraces(leakedNodeIds: HeapNodeIdSet, snapshot: IHeapSnapshot, options?: WorkDirOptions): Promise<LeakTracePathItem[]>;
     /**
      * Given a set of heap object ids, cluster them based on the similarity
-     * of their retainer traces and return a
+     * of their retainer traces
      * @param leakedNodeIds
      * @param snapshot
      * @returns
@@ -43,7 +50,7 @@ declare class MemoryAnalyst {
     serializeClusterUpdate(clusters: TraceCluster[], options?: {
         reclusterOnly?: boolean;
     }): Promise<void>;
-    dumpPathByNodeId(leakedIdSet: HeapNodeIdSet, snapshot: IHeapSnapshot, nodeIdsInSnapshots: Array<HeapNodeIdSet>, id: number, pathLoaderFile: string, summaryFile: string): void;
+    dumpPathByNodeId(leakedIdSet: HeapNodeIdSet, snapshot: IHeapSnapshot, nodeIdsInSnapshots: Array<HeapNodeIdSet>, id: number, pathLoaderFile: string, summaryFile: string, options?: WorkDirOptions): void;
 }
 declare const _default: MemoryAnalyst;
 export default _default;