@memlab/core 1.1.16 → 1.1.18

package/dist/lib/Config.d.ts

@@ -8,8 +8,7 @@
  * @oncall web_perf_infra
  */
 import type { LaunchOptions, Permission } from 'puppeteer';
-import type { AnyFunction, AnyValue, IClusterStrategy, IRunningMode, IScenario, Nullable, Optional, QuickExperiment, ILeakFilter, IPackageInfo } from './Types';
-import { IHeapConfig } from '..';
+import type { AnyFunction, AnyValue, FileOption, IClusterStrategy, IRunningMode, IScenario, IHeapConfig, Nullable, Optional, QuickExperiment, ILeakFilter, IPackageInfo } from './Types';
 interface BrowserLaunchArgumentOptions {
     headless?: boolean;
     userDataDir?: string;
@@ -71,6 +70,7 @@ export declare class MemLabConfig {
     userDataDir: string;
     curDataDir: string;
     webSourceDir: string;
+    debugDataDir: string;
     runMetaFile: string;
     snapshotSequenceFile: string;
     exploreResultFile: string;
@@ -90,6 +90,7 @@ export declare class MemLabConfig {
     traceClusterOutDir: string;
     traceJsonOutDir: string;
     metricsOutDir: string;
+    heapAnalysisLogDir: string;
     reportScreenshotFile: string;
     newUniqueClusterDir: string;
     staleUniqueClusterDir: string;
@@ -215,6 +216,8 @@ export declare class MemLabConfig {
     set disableWebSecurity(disable: boolean);
     get disableWebSecurity(): boolean;
     get browserBinaryPath(): string;
+    set defaultFileManagerOption(fileOption: FileOption);
+    get defaultFileManagerOption(): FileOption;
     set reportLeaksInTimers(shouldReport: boolean);
     get reportLeaksInTimers(): boolean;
     setDevice(deviceName: string, options?: {

package/dist/lib/Config.js

@@ -8,6 +8,29 @@
  * @format
  * @oncall web_perf_infra
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -17,7 +40,7 @@ const path_1 = __importDefault(require("path"));
 const RunningModes_1 = __importDefault(require("../modes/RunningModes"));
 const Console_1 = __importDefault(require("./Console"));
 const Constant_1 = __importDefault(require("./Constant"));
-const FileManager_1 = __importDefault(require("./FileManager"));
+const FileManager_1 = __importStar(require("./FileManager"));
 const InternalValueSetter_1 = require("./InternalValueSetter");
 const devices = Constant_1.default.isFRL
     ? {}
@@ -429,6 +452,17 @@ class MemLabConfig {
     get browserBinaryPath() {
         return path_1.default.join(this.browserDir, this.browser);
     }
+    // Default input option for file manager.
+    // If no other input option is provided, the file manager
+    // will generate directories and files based on this default option.
+    set defaultFileManagerOption(fileOption) {
+        FileManager_1.FileManager.defaultFileOption = fileOption;
+        // initialize file and directory paths
+        FileManager_1.default.initDirs(this, fileOption);
+    }
+    get defaultFileManagerOption() {
+        return FileManager_1.FileManager.defaultFileOption;
+    }
     set reportLeaksInTimers(shouldReport) {
         if (shouldReport) {
             this.removeFromSet(this.nodeNameBlockList, this._timerNodes);

package/dist/lib/Console.d.ts

@@ -23,6 +23,7 @@ declare class MemLabConsole {
     private config;
     private sections;
     private log;
+    private logFileSet;
     private styles;
     private static singleton;
     protected constructor();
@@ -40,6 +41,8 @@ declare class MemLabConsole {
     private shouldBeConcise;
     private clearPrevOverwriteMsg;
     private printStr;
+    registerLogFile(logFile: string): void;
+    unregisterLogFile(logFile: string): void;
     beginSection(name: string): void;
     endSection(name: string): void;
     setConfig(config: MemLabConfig): void;

package/dist/lib/Console.js

@@ -14,10 +14,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const chalk_1 = __importDefault(require("chalk"));
 const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const readline_1 = __importDefault(require("readline"));
 const string_width_1 = __importDefault(require("string-width"));
 const stdout = process.stdout;
 const TABLE_MAX_WIDTH = 50;
+const LOG_BUFFER_LENGTH = 100;
 const prevLine = '\x1b[F';
 const eraseLine = '\x1b[K';
 const barComplete = chalk_1.default.green('\u2588');
@@ -42,10 +44,21 @@ function formatTableArg(arg) {
         }
     });
 }
+function registerExitCleanup(inst, exitHandler) {
+    const p = process;
+    // normal exit
+    p.on('exit', exitHandler.bind(null, { cleanup: true }));
+    // ctrl + c event
+    p.on('SIGINT', exitHandler.bind(null, { exit: true }));
+    // kill pid
+    p.on('SIGUSR1', exitHandler.bind(null, { exit: true }));
+    p.on('SIGUSR2', exitHandler.bind(null, { exit: true }));
+}
 class MemLabConsole {
     constructor() {
         this.config = {};
         this.log = [];
+        this.logFileSet = new Set();
         this.styles = {
             top: (msg) => msg,
             high: chalk_1.default.dim.bind(chalk_1.default),
@@ -67,12 +80,15 @@ class MemLabConsole {
         }
         const inst = new MemLabConsole();
         MemLabConsole.singleton = inst;
-        // clean up output
+        const exitHandler = (
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        _options, 
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        process.on('exit', (_code) => {
-            inst.flushLog();
+        _exitCode) => {
+            inst.flushLog({ sync: true });
             inst.clearPrevOverwriteMsg();
-        });
+        };
+        registerExitCleanup(inst, exitHandler);
         return inst;
     }
     style(msg, name) {
@@ -98,28 +114,49 @@ class MemLabConsole {
     }
     logMsg(msg) {
         // remove control characters
-        const rawMsg = msg
+        const lines = msg.split('\n').map(line => line
             // eslint-disable-next-line no-control-regex
             .replace(/[\u0000-\u001F\u007F-\u009F]/g, '')
-            .replace(/\[\d{1,3}m/g, '');
-        this.log.push(rawMsg);
-        if (this.log.length > 20) {
-            this.flushLog();
+            .replace(/\[\d{1,3}m/g, ''));
+        this.log.push(...lines);
+        if (this.log.length > LOG_BUFFER_LENGTH) {
+            this.flushLog({ sync: true });
         }
     }
-    flushLog() {
+    flushLog(options = {}) {
         const str = this.log.join('\n');
-        if (str.length > 0) {
-            const file = this.config.consoleLogFile;
-            fs_1.default.appendFile(file, str + '\n', 'UTF-8', () => {
-                // NOOP
-            });
-        }
         this.log = [];
+        if (str.length === 0) {
+            return;
+        }
+        // synchronous logging
+        if (options.sync) {
+            for (const logFile of this.logFileSet) {
+                try {
+                    fs_1.default.appendFileSync(logFile, str + '\n', 'UTF-8');
+                }
+                catch (_a) {
+                    // fail silently
+                }
+            }
+        }
+        else {
+            // async logging
+            const emptyCallback = () => {
+                // no op
+            };
+            for (const logFile of this.logFileSet) {
+                try {
+                    fs_1.default.appendFile(logFile, str + '\n', 'UTF-8', emptyCallback);
+                }
+                catch (_b) {
+                    // fail silently
+                }
+            }
+        }
     }
     pushMsg(msg, options = {}) {
-        const len = this.sections.arr.length;
-        if (this.config.isContinuousTest || len === 0) {
+        if (this.sections.arr.length === 0) {
             return;
         }
         // calculate each line's visible width
@@ -140,7 +177,9 @@ class MemLabConsole {
         if (!section || section.msgs.length === 0) {
             return;
         }
-        stdout.write(eraseLine);
+        if (!this.config.muteConsole) {
+            stdout.write(eraseLine);
+        }
         const msg = section.msgs.pop();
         if (!msg) {
             return;
@@ -150,8 +189,10 @@ class MemLabConsole {
             const line = (_a = lines.pop()) !== null && _a !== void 0 ? _a : 0;
             const width = stdout.columns;
             let n = line === 0 ? 1 : Math.ceil(line / width);
-            while (n-- > 0) {
-                stdout.write(prevLine + eraseLine);
+            if (!this.config.muteConsole && !this.config.isTest) {
+                while (n-- > 0) {
+                    stdout.write(prevLine + eraseLine);
+                }
             }
         }
     }
@@ -189,11 +230,21 @@ class MemLabConsole {
         this.clearPrevMsgInLastSection();
     }
     printStr(msg, options = {}) {
-        if (this.config.isTest || this.config.muteConsole) {
+        this.pushMsg(msg, options);
+        if (this.config.isTest) {
             return;
         }
-        console.log(msg);
-        this.pushMsg(msg, options);
+        if (this.config.isContinuousTest || !this.config.muteConsole) {
+            console.log(msg);
+        }
+    }
+    registerLogFile(logFile) {
+        this.flushLog({ sync: true });
+        this.logFileSet.add(path_1.default.resolve(logFile));
+    }
+    unregisterLogFile(logFile) {
+        this.flushLog({ sync: true });
+        this.logFileSet.delete(path_1.default.resolve(logFile));
     }
     beginSection(name) {
         if (this.config.isContinuousTest) {
@@ -300,14 +351,16 @@ class MemLabConsole {
         this.printStr('');
     }
     overwrite(msg, options = {}) {
-        if (this.config.isTest || this.config.muteConsole) {
+        const str = this.style(msg, options.level || 'low');
+        if (this.config.isContinuousTest) {
+            this.printStr(msg, { isOverwrite: false });
             return;
         }
-        if (this.config.isContinuousTest) {
-            return console.log(msg);
+        if (this.config.isTest || this.config.muteConsole) {
+            this.printStr(str, { isOverwrite: true });
+            return;
         }
         this.clearPrevOverwriteMsg();
-        const str = this.style(msg, options.level || 'low');
         this.printStr(str, { isOverwrite: true });
     }
     waitForConsole(query) {

package/dist/lib/FileManager.d.ts

@@ -8,32 +8,31 @@
  * @oncall web_perf_infra
  */
 import type { MemLabConfig } from './Config';
-import type { AnyValue, Optional } from './Types';
-/** @internal */
-export declare type FileOption = {
-    workDir?: Optional<string>;
-    clear?: boolean;
-    transient?: boolean;
-};
+import type { AnyValue, FileOption } from './Types';
 /** @internal */
 export declare class FileManager {
     getDefaultWorkDir(): string;
     generateTmpHeapDir(): string;
     private static transientInstanceIdx;
+    static defaultFileOption: FileOption;
     getWorkDir(options?: FileOption): string;
     getChromeBinaryZipFile(): string;
     getChromeBinaryTimeStampFile(): string;
     getChromeBinaryDir(): string;
-    clearUserDataDir(options: FileOption): void;
-    getDataBaseDir(options: FileOption): string;
+    getDataBaseDir(options?: FileOption): string;
     getCodeDataDir(): string;
     getClusterSampleDataDir(): string;
-    getUserDataDir(options: FileOption): string;
-    getCurDataDir(options: FileOption): string;
+    getUserDataDir(options?: FileOption): string;
+    clearUserDataDir(options?: FileOption): void;
+    getCurDataDir(options?: FileOption): string;
     getWebSourceDir(options?: FileOption): string;
     getWebSourceMetaFile(options?: FileOption): string;
-    getPersistDataDir(options: FileOption): string;
+    getDebugDataDir(options?: FileOption): string;
+    getDebugSourceFile(options?: FileOption): string;
+    getPersistDataDir(options?: FileOption): string;
     getLoggerOutDir(options?: FileOption): string;
+    getHeapAnalysisLogDir(options?: FileOption): string;
+    getHeapSaveLogJSONFile(options?: FileOption): string;
     getTraceClustersDir(options?: FileOption): string;
     getTraceJSONDir(options?: FileOption): string;
     getUnclassifiedTraceClusterDir(options?: FileOption): string;
@@ -61,6 +60,7 @@ export declare class FileManager {
         controlWorkDir: string;
         testWorkDir: string;
     };
+    initNewHeapAnalysisLogFile(options?: FileOption): string;
     getAndInitTSCompileIntermediateDir(): string;
     clearDataDirs(options?: FileOption): void;
     emptyDirIfExists(dir: string): void;

package/dist/lib/FileManager.js

@@ -24,7 +24,7 @@ function joinAndProcessDir(options, ...args) {
     const filepath = path_1.default.join(...args);
     if (!fs_extra_1.default.existsSync(filepath)) {
         try {
-            fs_extra_1.default.mkdirSync(filepath);
+            fs_extra_1.default.mkdirpSync(filepath);
         }
         catch (ex) {
             const err = Utils_1.default.getError(ex);
@@ -43,11 +43,11 @@ class FileManager {
     generateTmpHeapDir() {
         const dirPath = path_1.default.join(this.getTmpDir(), 'memlab-' + Utils_1.default.getUniqueID());
         if (!fs_extra_1.default.existsSync(dirPath)) {
-            fs_extra_1.default.mkdirSync(dirPath);
+            fs_extra_1.default.mkdirpSync(dirPath);
         }
         return dirPath;
     }
-    getWorkDir(options = {}) {
+    getWorkDir(options = FileManager.defaultFileOption) {
         // workDir options supercedes all the other options
         if (options.workDir) {
             return path_1.default.resolve(options.workDir);
@@ -73,11 +73,7 @@ class FileManager {
     getChromeBinaryDir() {
         return path_1.default.join(this.getDefaultWorkDir(), 'chrome');
     }
-    clearUserDataDir(options) {
-        const userDataDir = this.getUserDataDir(options);
-        this.rmDir(userDataDir);
-    }
-    getDataBaseDir(options) {
+    getDataBaseDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getWorkDir(options), 'data');
     }
     getCodeDataDir() {
@@ -86,56 +82,74 @@ class FileManager {
     getClusterSampleDataDir() {
         return path_1.default.join(this.getCodeDataDir(), 'cluster');
     }
-    getUserDataDir(options) {
+    getUserDataDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getDataBaseDir(options), 'profile');
     }
-    getCurDataDir(options) {
+    clearUserDataDir(options = FileManager.defaultFileOption) {
+        const userDataDir = this.getUserDataDir(options);
+        this.rmDir(userDataDir);
+    }
+    getCurDataDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getDataBaseDir(options), 'cur');
     }
-    getWebSourceDir(options = {}) {
+    getWebSourceDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getCurDataDir(options), 'code');
     }
-    getWebSourceMetaFile(options = {}) {
+    getWebSourceMetaFile(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getWebSourceDir(options), 'files.json');
     }
-    getPersistDataDir(options) {
+    getDebugDataDir(options = FileManager.defaultFileOption) {
+        return path_1.default.join(this.getDataBaseDir(options), 'debug');
+    }
+    getDebugSourceFile(options = FileManager.defaultFileOption) {
+        return path_1.default.join(this.getDebugDataDir(options), 'file.js');
+    }
+    getPersistDataDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getDataBaseDir(options), 'persist');
     }
-    getLoggerOutDir(options = {}) {
+    getLoggerOutDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getDataBaseDir(options), 'logger');
     }
+    // all heap analysis results generated
+    getHeapAnalysisLogDir(options = FileManager.defaultFileOption) {
+        return path_1.default.join(this.getLoggerOutDir(options), 'heap-analysis');
+    }
+    // memlab save-heap result log file
+    getHeapSaveLogJSONFile(options = FileManager.defaultFileOption) {
+        return path_1.default.join(this.getHeapAnalysisLogDir(options), 'save-heap.json');
+    }
     // all trace clusters generated from the current run
-    getTraceClustersDir(options = {}) {
+    getTraceClustersDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getLoggerOutDir(options), 'trace-clusters');
     }
     // stores JSON file (with heap object and reference details for visualization)
     // of all trace clusters (each cluster has a representative trace)
-    getTraceJSONDir(options = {}) {
+    getTraceJSONDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getLoggerOutDir(options), 'trace-jsons');
     }
-    getUnclassifiedTraceClusterDir(options = {}) {
+    getUnclassifiedTraceClusterDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getLoggerOutDir(options), 'unclassified-clusters');
     }
-    getUniqueTraceClusterDir(options = {}) {
+    getUniqueTraceClusterDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getLoggerOutDir(options), 'unique-trace-clusters');
     }
-    getNewUniqueTraceClusterDir(options = {}) {
+    getNewUniqueTraceClusterDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getUniqueTraceClusterDir(options), 'add');
     }
-    getStaleUniqueTraceClusterDir(options = {}) {
+    getStaleUniqueTraceClusterDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getUniqueTraceClusterDir(options), 'delete');
     }
-    getAllClusterSummaryFile(options = {}) {
+    getAllClusterSummaryFile(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getUniqueTraceClusterDir(options), 'unique-clusters-summary.txt');
     }
-    getExistingUniqueTraceClusterDir(options = {}) {
+    getExistingUniqueTraceClusterDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getUniqueTraceClusterDir(options), 'existing');
     }
     getAllFilesInDir(dir) {
         const files = fs_extra_1.default.readdirSync(dir);
         return files.map((file) => path_1.default.join(dir, file));
     }
-    getDataOutDir(options = {}) {
+    getDataOutDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getDataBaseDir(options), 'out');
     }
     getCoreProjectBaseDir() {
@@ -147,19 +161,19 @@ class FileManager {
     getDocDir() {
         return path_1.default.join(this.getMonoRepoDir(), 'website', 'docs');
     }
-    getReportOutDir(options = {}) {
+    getReportOutDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getPersistDataDir(options), 'reports');
     }
-    getPreviewReportDir(options = {}) {
+    getPreviewReportDir(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getPersistDataDir(options), 'report-preview');
     }
-    getLeakSummaryFile(options = {}) {
+    getLeakSummaryFile(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getDataOutDir(options), 'leaks.txt');
     }
-    getRunMetaFile(options = {}) {
+    getRunMetaFile(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getCurDataDir(options), 'run-meta.json');
     }
-    getSnapshotSequenceMetaFile(options = {}) {
+    getSnapshotSequenceMetaFile(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getCurDataDir(options), 'snap-seq.json');
     }
     getInputDataDir() {
@@ -182,6 +196,7 @@ class FileManager {
         }
         return ret;
     }
+    // system default tmp dir
     getTmpDir() {
         return os_1.default.tmpdir();
     }
@@ -200,18 +215,28 @@ class FileManager {
         const testWorkDir = joinAndProcessDir({}, expDir, 'test');
         return { controlWorkDir, testWorkDir };
     }
+    // create a unique log file created for heap analysis output
+    initNewHeapAnalysisLogFile(options = FileManager.defaultFileOption) {
+        const dir = this.getHeapAnalysisLogDir(options);
+        const file = path_1.default.join(dir, `analysis-${Utils_1.default.getUniqueID()}-out.log`);
+        if (!fs_extra_1.default.existsSync(file)) {
+            fs_extra_1.default.createFileSync(file);
+        }
+        return file;
+    }
     getAndInitTSCompileIntermediateDir() {
         const dir = path_1.default.join(this.getTmpDir(), 'memlab-code');
         this.rmDir(dir);
-        fs_extra_1.default.mkdirSync(dir);
+        fs_extra_1.default.mkdirpSync(dir);
         return dir;
     }
-    clearDataDirs(options = {}) {
+    clearDataDirs(options = FileManager.defaultFileOption) {
         const curDataDir = this.getCurDataDir(options);
         if (!fs_extra_1.default.existsSync(curDataDir)) {
             return;
         }
         this.emptyDirIfExists(this.getWebSourceDir(options));
+        this.emptyDirIfExists(this.getDebugDataDir(options));
         const dataSuffix = ['.heapsnapshot', '.json', '.png'];
         const files = fs_extra_1.default.readdirSync(curDataDir);
         for (const file of files) {
@@ -229,7 +254,7 @@ class FileManager {
             fs_extra_1.default.emptyDirSync(dir);
         }
     }
-    emptyTraceLogDataDir(options = {}) {
+    emptyTraceLogDataDir(options = FileManager.defaultFileOption) {
         // all leak trace clusters
         this.emptyDirIfExists(this.getTraceClustersDir(options));
         // all JSON files for trace visualization
@@ -238,6 +263,8 @@ class FileManager {
         this.emptyDirIfExists(this.getUnclassifiedTraceClusterDir(options));
         // all unique cluster info
         this.emptyDirIfExists(this.getUniqueTraceClusterDir(options));
+        // all heap analysis results
+        this.emptyDirIfExists(this.getHeapAnalysisLogDir(options));
     }
     resetBrowserDir() {
         try {
@@ -268,7 +295,7 @@ class FileManager {
             this.iterateAllFiles(filepath, callback);
         });
     }
-    rmWorkDir(options = {}) {
+    rmWorkDir(options = FileManager.defaultFileOption) {
         try {
             this.rmDir(this.getWorkDir(options));
         }
@@ -281,7 +308,7 @@ class FileManager {
         const internalDir = Constant_1.default.internalDir;
         return filePath.includes(`${sep}${internalDir}${sep}`);
     }
-    initDirs(config, options = {}) {
+    initDirs(config, options = FileManager.defaultFileOption) {
         config.monoRepoDir = Constant_1.default.monoRepoDir;
         // make sure getWorkDir is called first before
         // any other get file or get dir calls
@@ -294,9 +321,12 @@ class FileManager {
         const outDir = joinAndProcessDir(options, this.getDataOutDir(options));
         config.curDataDir = joinAndProcessDir(options, this.getCurDataDir(options));
         config.webSourceDir = joinAndProcessDir(options, this.getWebSourceDir(options));
+        config.debugDataDir = joinAndProcessDir(options, this.getDebugDataDir(options));
         config.dataBuilderDataDir = joinAndProcessDir(options, config.dataBaseDir, 'dataBuilder');
         config.persistentDataDir = joinAndProcessDir(options, this.getPersistDataDir(options));
+        // register the default log file
         config.consoleLogFile = path_1.default.join(config.curDataDir, 'console-log.txt');
+        Console_1.default.registerLogFile(config.consoleLogFile);
         config.runMetaFile = this.getRunMetaFile(options);
         config.snapshotSequenceFile = this.getSnapshotSequenceMetaFile(options);
         config.browserInfoSummary = path_1.default.join(config.curDataDir, 'browser-info.txt');
@@ -314,6 +344,8 @@ class FileManager {
         config.traceClusterOutDir = joinAndProcessDir(options, this.getTraceClustersDir(options));
         // detailed trace json files for visualization
         config.traceJsonOutDir = joinAndProcessDir(options, this.getTraceJSONDir(options));
+        // heap analysis results
+        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();
@@ -329,4 +361,5 @@ class FileManager {
 }
 exports.FileManager = FileManager;
 FileManager.transientInstanceIdx = 0;
+FileManager.defaultFileOption = {};
 exports.default = new FileManager();

package/dist/lib/HeapAnalyzer.d.ts

@@ -7,15 +7,10 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { E2EStepInfo, HeapNodeIdSet, IHeapNode, IHeapSnapshot, IMemoryAnalystOptions, IMemoryAnalystSnapshotDiff, LeakTracePathItem, Optional, IOveralLeakInfo, TraceCluster, ISerializedInfo } from './Types';
+import type { E2EStepInfo, HeapNodeIdSet, IHeapSnapshot, IMemoryAnalystOptions, IMemoryAnalystSnapshotDiff, IOveralHeapInfo, LeakTracePathItem, Optional, IOveralLeakInfo, TraceCluster, ISerializedInfo } from './Types';
 import TraceFinder from '../paths/TraceFinder';
 declare class MemoryAnalyst {
     checkLeak(): Promise<ISerializedInfo[]>;
-    checkUnbound(options?: IMemoryAnalystOptions): Promise<void>;
-    breakDownMemoryByShapes(options?: {
-        file?: string;
-    }): Promise<void>;
-    detectUnboundGrowth(options?: IMemoryAnalystOptions): Promise<void>;
     detectMemoryLeaks(): Promise<ISerializedInfo[]>;
     visualizeMemoryUsage(options?: IMemoryAnalystOptions): void;
     focus(options?: {
@@ -23,19 +18,15 @@ declare class MemoryAnalyst {
     }): Promise<void>;
     shouldLoadCompleteSnapshot(tabsOrder: E2EStepInfo[], tab: E2EStepInfo): boolean;
     diffSnapshots(loadAll?: boolean): Promise<IMemoryAnalystSnapshotDiff>;
-    private calculateRetainedSizes;
     preparePathFinder(snapshot: IHeapSnapshot): TraceFinder;
     private dumpPageInteractionSummary;
     private dumpLeakSummaryToConsole;
     private filterLeakedObjects;
-    aggregateDominatorMetrics(ids: HeapNodeIdSet, snapshot: IHeapSnapshot, checkNodeCb: (node: IHeapNode) => boolean, nodeMetricsCb: (node: IHeapNode) => number): number;
-    private getOverallHeapInfo;
-    getRetainedSize(node: IHeapNode): number;
+    getOverallHeapInfo(snapshot: IHeapSnapshot, options?: {
+        force?: boolean;
+    }): Optional<IOveralHeapInfo>;
     getOverallLeakInfo(leakedNodeIds: HeapNodeIdSet, snapshot: IHeapSnapshot): Optional<IOveralLeakInfo>;
-    private printHeapInfo;
-    private breakDownSnapshotByShapes;
-    private isTrivialEdgeForBreakDown;
-    private breakDownByReferrers;
+    printHeapInfo(leakInfo: IOveralHeapInfo): void;
     private printHeapAndLeakInfo;
     private logLeakTraceSummary;
     searchLeakedTraces(leakedNodeIds: HeapNodeIdSet, snapshot: IHeapSnapshot): Promise<{