meminsight-test-demo 1.0.0

package/packages/core/src/utils/Output.ts

@@ -0,0 +1,271 @@
+
+import { TextWriter, JsonWriter, HtmlWriter } from '../file/FileWriter';
+import { ILoggable, Log } from './Log';
+
+/**
+ * output type
+ */
+export enum OutputType {
+    CONSOLE = 'console',
+    TEXT = 'txt',
+    JSON = 'json',
+    HTML = 'html'
+}
+
+/**
+ * output config
+ */
+export type OutputCfg = {
+    desc: any;
+    output: {
+        dir: string;
+        filename: string;
+        extension: string;
+    }
+    node?:  {
+        enableId: boolean,
+        enableType: boolean,
+        enableName: boolean,
+        enableSelfSize: boolean,
+        enableRetainedSize: boolean
+    }
+}
+
+/**
+ * output interface
+ */
+export interface IOutput {
+    type: OutputType;
+    output(data: any, cfg: OutputCfg): void;
+}
+
+/**
+ * console data
+ */
+export class ConsoleData {
+    table: boolean;
+    data: any;
+
+    constructor(table: boolean, data: any) {
+        this.table = table;
+        this.data = data;
+    }
+}
+
+/**
+ * console table data
+ */
+export class ConsoleTableData {
+    title: string[];
+    data: any[];
+
+    constructor(title: string[], data: any[]) {
+        this.title = title;
+        this.data = data;
+    }
+}
+
+/**
+ * text data
+ */
+export class TextData {
+    desc: any;
+    data: any;
+
+    constructor(desc: any, data: any) {
+        this.desc = desc;
+        this.data = data;
+    }
+}
+
+/**
+ * json data
+ */
+export class JsonData {
+    desc: any;
+    data: any;
+
+    constructor(desc: any, data: any) {
+        this.desc = desc;
+        this.data = data;
+    }
+}
+
+/**
+ * html data
+ */
+export class HtmlData {
+    desc: any;
+    data: any;
+    template: string;
+    delimiter: string;
+
+    constructor(desc: any, data: any, template?: string) {
+        this.desc = desc;
+        this.data = data;
+        this.template = template || '';
+        this.delimiter = 'DATA=';
+    }
+}
+
+/**
+ * base output
+ */
+abstract class BaseOutput implements IOutput, ILoggable {
+    public readonly type: OutputType;
+    public readonly DOMAIN: string = 'meminsight';
+    public readonly TAG: string;
+
+    constructor(type: OutputType) {
+        this.type = type;
+        this.TAG = type.toString();
+    }
+
+    public output(data: any, cfg?: OutputCfg): void {}
+
+    protected getFilePathByCfg(cfg?: OutputCfg) : string {
+    if (cfg && cfg.output.filename != '') {
+        return `${cfg.output.dir}/${cfg.output.filename}.${cfg.output.extension}`;
+    } else {
+        let dir = './output';
+        let filename = `output_${Date.now()}`;
+        let extension = this.type.toString();
+        return `${dir}/${filename}.${extension}`;
+    }
+}
+}
+
+/**
+ * console output
+ */
+export class ConsoleOutput extends BaseOutput {
+    constructor() {
+        super(OutputType.CONSOLE);
+    }
+
+    public output(data: any, cfg?: OutputCfg): void {
+        const consoleData = data as ConsoleData;
+        if (consoleData) {
+            if (cfg?.desc) {
+                console.log(cfg?.desc);
+            }
+            if (consoleData.table) {
+                const tableData = consoleData.data as ConsoleTableData;
+                console.table(tableData.data, tableData.title);
+            } else {
+                console.log(consoleData.data);
+            }
+        } else {
+            if (typeof data === 'string') {
+                 console.log(data);
+            } else {
+                Log.errorX(this, 'No data to output');
+            }
+        }
+    }
+}
+
+/**
+ * text output
+ */
+export class TextOutput extends BaseOutput {
+    constructor() {
+        super(OutputType.TEXT);
+    }
+
+    public output(data: any, cfg?: OutputCfg): void {
+        let filePath = this.getFilePathByCfg(cfg);
+        let textData = data as TextData;
+        if (textData) {
+            const tmpData = {
+                'meta': cfg?.desc,
+                'data': textData,
+            }
+            TextWriter.instance().writeToFile(filePath, JSON.stringify(tmpData), 'utf-8');
+        } else {
+            if (typeof data === 'string') {
+                TextWriter.instance().writeToFile(filePath, data, 'utf-8');
+            } else {
+                Log.errorX(this, 'No data to output');
+            }
+        }
+    }
+}
+
+/**
+ * json output
+ */
+export class JsonOutput extends BaseOutput {
+    constructor() {
+        super(OutputType.JSON);
+    }
+
+    public output(data: any, cfg?: OutputCfg): void {
+        let filePath = this.getFilePathByCfg(cfg);
+        let jsonData = data as JsonData;
+        if (jsonData) {
+            const tmpData = {
+                'meta': jsonData.desc,
+                'data': jsonData.data
+            }
+            JsonWriter.instance().writeToFile(filePath, tmpData, 'utf-8');
+        } else {
+            if (typeof data === 'string') {
+                JsonWriter.instance().writeToFile(filePath, data, 'utf-8');
+            } else {
+                Log.errorX(this, 'No data to output');
+            }
+        }
+    }
+}
+
+/**
+ * html output
+ */
+export class HtmlOutput extends BaseOutput {
+    constructor() {
+        super(OutputType.HTML);
+    }
+
+    public output(data: any, cfg?: OutputCfg): void {
+       let filePath = this.getFilePathByCfg(cfg);
+        let htmlData = data as HtmlData;
+        if (htmlData) {
+            const tmpData = {
+                'meta': cfg?.desc,
+                'data': htmlData,
+            }
+            HtmlWriter.instance().writeToFile(filePath, JSON.stringify(tmpData), 'utf-8');
+        } else {
+            if (typeof data === 'string') {
+                HtmlWriter.instance().writeToFile(filePath, data, 'utf-8');
+            } else {
+                Log.errorX(this, 'No data to output');
+            }
+        }
+    }
+}
+
+/**
+ * output factory
+ */
+export class OutputFactory {
+    private static _defaultOutput: IOutput = new ConsoleOutput();
+    private static OUTPUT_MAP: Map<string, IOutput> = new Map(
+        [
+            [OutputType.CONSOLE.toString(), OutputFactory._defaultOutput],
+            [OutputType.HTML.toString(), new HtmlOutput()],
+            [OutputType.JSON.toString(), new JsonOutput()],
+            [OutputType.TEXT.toString(), new TextOutput()],
+        ]
+    );
+    
+
+    public static getOutput(type: string): IOutput {
+        let output = OutputFactory.OUTPUT_MAP.get(type);
+        if (!output) {
+            return OutputFactory._defaultOutput;
+        }
+        return output;
+    }
+}

package/packages/core/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "rootDir": "./src",
+    },
+    "include": [
+        "./src/**/*"
+    ]
+}

package/packages/exampletools/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@meminsight/example-tools",
+    "version": "1.0.0",
+    "description": "example-tools for memory analysis.",
+    "author": { 
+        "name": "meminsight-example-tools"
+    },
+    "scripts": {
+        "build": "tsc",
+        "test": "jest",
+        "publish": "npm publish",
+        "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo",
+        "clean-all": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo && rm -rf ./node_modules && find ./src -type f -name \"*.js\" -exec rm -f {} +"
+    },
+    "main": "dist/MemTest.js",
+    "bin": "dist/MemTest.js",
+    "engines": {
+        "node": ">=16.0.0"
+    },
+    "dependencies": {
+        "@memlab/core": "^1.0.40",
+        "@memlab/heap-analysis": "^1.0.40",
+        "@types/node": "^22.14.1",
+        "@types/jest": "^29.1.1",
+        "@types/ejs": "^3.1.5",
+        "ejs": "^3.1.10",
+        "axios": "^1.1.3",
+        "ansi": "^0.3.1",
+        "fs-extra": "^11.2.0",
+        "string-width": "^7.2.0",
+        "babar": "^0.2.0",
+        "chalk": "^5.4.1",
+        "minimist": "^1.2.8",
+        "util.promisify": "^1.1.1",
+        "node-xlsx": "^0.24.0",
+        "jest": "^29.1.1",
+        "typescript": "^5.3.3"
+    },
+    "devDependencies": {
+        "@types/fs-extra": "^11.0.4",
+        "@types/node": "^22.14.1",
+        "@types/minimist": "^1.2.2",
+        "@types/jest": "^29.1.1",
+        "jest": "^29.7.0",
+        "ts-jest": "^29.1.1",
+        "ts-node": "^10.9.1",
+        "typescript": "^5.3.3"
+    },
+    "workspaces": [
+        "../packages/core"
+    ]
+}

package/packages/exampletools/src/MemTest.ts

@@ -0,0 +1,64 @@
+import { 
+    OutputFactory, OutputCfg, OutputType, 
+    Finder, Loader, 
+    ArkSerializer, ArkNodeTracePath,
+    Log
+} from '@meminsight/core';
+
+const DOMAIN: string = 'exampletools';
+const TAG: string = 'memtest';
+
+const args = process.argv.slice();
+const type = args.length > 2 ? Number(args[2]) : 0;
+const count = args.length > 3 ? Number(args[3]) : 5;
+const nodeName = args.length > 4 ? args[4] : '';
+const filepath = args.length > 5 ? args[5] : '';
+
+function error(msg: string) {
+    Log.error(DOMAIN, TAG, msg);
+}
+
+function info(msg: string) {
+    Log.info(DOMAIN, TAG, msg);
+}
+
+(async function () {
+    if (filepath === '') {
+        error('filepath is empty.');
+        return;
+    }
+    const snapshot = await Loader.loadFromFile(filepath);
+
+    if (type === 0) {
+        const nodes = Finder.findNodesByNameCount(snapshot, nodeName, count);
+        const cfg: OutputCfg = {
+            desc: '',
+            output: {
+                dir: '',
+                filename: '',
+                extension: OutputType.CONSOLE.toString(),
+            },  
+            node: {
+                enableId: true,
+                enableType: true,
+                enableName: true,
+                enableSelfSize: false,
+                enableRetainedSize: false,
+            }
+        };
+        let nodeData = ArkSerializer.getConsoleDataByNodes(true, nodes, cfg);
+        OutputFactory.getOutput(OutputType.CONSOLE).output(nodeData, cfg);
+    } else {
+        const nodes = Finder.findNodesByNameCount(snapshot, nodeName, count);
+        const shortestPaths = Finder.findShortestPaths(snapshot, nodes);
+        let set = new Set<number>();
+        shortestPaths.forEach(item => {
+            if (item) {
+                let tracePath = new ArkNodeTracePath(item, true);
+                let pathStr = tracePath.getTracePathInfo();
+                console.log(pathStr);
+                console.log('\n');
+            }
+        });
+    }
+})();

package/packages/exampletools/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "rootDir": "./src",
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "references": [
+        {
+            "path": "../core"
+        }
+    ]
+}

package/packages/meminsight/jest.config.js

@@ -0,0 +1,8 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} **/
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.ts?$': 'ts-jest',
+  },
+};

package/packages/meminsight/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@meminsight/cmd",
+    "version": "1.0.0",
+    "description": "meminsight binary is a command tool for memory analysis.",
+    "author": { 
+        "name": "meminsight-cmd"
+    },
+    "scripts": {
+        "build": "tsc",
+        "test": "jest",
+        "publish": "npm publish",
+        "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo",
+        "clean-all": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo && rm -rf ./node_modules && find ./src -type f -name \"*.js\" -exec rm -f {} +"
+    },
+    "main": "dist/Index.js",
+    "bin": "dist/Index.js",
+    "engines": {
+        "node": ">=16.0.0"
+    },
+    "dependencies": {
+        "@memlab/core": "^1.0.40",
+        "@memlab/heap-analysis": "^1.0.40",
+        "@types/node": "^22.14.1",
+        "@types/jest": "^29.1.1",
+        "@types/ejs": "^3.1.5",
+        "ejs": "^3.1.10",
+        "axios": "^1.1.3",
+        "ansi": "^0.3.1",
+        "fs-extra": "^11.2.0",
+        "string-width": "^7.2.0",
+        "babar": "^0.2.0",
+        "chalk": "^5.4.1",
+        "minimist": "^1.2.8",
+        "util.promisify": "^1.1.1",
+        "node-xlsx": "^0.24.0",
+        "jest": "^29.1.1",
+        "typescript": "^5.3.3"
+    },
+    "devDependencies": {
+        "@types/fs-extra": "^11.0.4",
+        "@types/node": "^22.14.1",
+        "@types/minimist": "^1.2.2",
+        "@types/jest": "^29.1.1",
+        "jest": "^29.7.0",
+        "ts-jest": "^29.1.1",
+        "ts-node": "^10.9.1",
+        "typescript": "^5.3.3"
+    },
+    "workspaces": [
+        "../packages/core"
+    ]
+}

package/packages/meminsight/src/Index.ts

@@ -0,0 +1,4 @@
+
+import { meminsight as cmdtools } from './process/HMemXProc';
+
+cmdtools.work();

package/packages/meminsight/src/Version.ts

@@ -0,0 +1,7 @@
+export enum Version {
+    HMEMX = '0.0.1',
+    ARK_GC = '0.0.1',
+    ARK_STAT = '0.0.1',
+    ARK_LEAK = '0.0.1',
+    ARK_COMPARE = '0.0.1'
+}

package/packages/meminsight/src/process/ArkCompareProc.ts

@@ -0,0 +1,160 @@
+import { Command } from "commander";
+import { 
+    ILoggable, Log, 
+    IAnalyzer, ArkCompareAnalyzer, ArkCmpCfg, defaultArkCmpCfg,
+    IOutput, OutputCfg, OutputFactory, OutputType,
+    JsonReader,
+    ConsoleData,
+    JsonData,
+    TextData,
+    HtmlData
+} from "@meminsight/core";
+import { IProcess } from "./IProcess";
+import { Version } from "../Version";
+import { outputFile } from "fs-extra";
+
+/**
+ * Ark Compare Process
+ */
+export class ArkCompareProc implements IProcess, ILoggable { 
+    public readonly DOMAIN: string = 'meminsight';
+    public readonly TAG: string = ArkCompareProc.name;
+    public static readonly CMD: string = 'ark-compare';
+    public static readonly DESC: string = "ark compare process.";
+    public static readonly VER: string = Version.ARK_COMPARE.toString();
+    private static _instance: ArkCompareProc; 
+    private _analyzer: IAnalyzer = new ArkCompareAnalyzer();
+
+    private constructor() {}
+
+    /**
+     * get instance
+     * @returns instance
+     */
+    public static instance(): ArkCompareProc {
+        if (!ArkCompareProc._instance) {
+            ArkCompareProc._instance = new ArkCompareProc();
+        }
+        return ArkCompareProc._instance;
+    }
+
+    public initialize(proc: Command, any: any) {
+        proc.command(ArkCompareProc.CMD)
+            .description(ArkCompareProc.DESC)
+            .requiredOption("-s, --source <file>", "source heapsnapshot file")
+            .requiredOption("-t, --target <file>", "target heapsnapshot file")
+            .option("-n, --node_name <node name>", undefined)
+            .option<number>("-S, --sort_type <sort type: 0 - count | 1 - self_size | 2 - retained_size>", "sort type", parseInt, 0)
+            .option("-c, --config <configuration file>", "configuration file")
+            .option("-o, --output <file>", "output file")
+            .option("-f, --output_file <file type>", "output file type, console | text | json | html.")
+            .action(async (options) => {
+                await ArkCompareProc.instance().process(new Map<string, any>([
+                    ["source", options.source],
+                    ["target", options.target || undefined],
+                    ["node_name", options.node_name || undefined],
+                    ["sort_type", options.sort_type || "count"],
+                    ["config", options.config || undefined],
+                    ["output", options.output],
+                    ["output_file", options.output_file],
+                ]));
+            });
+    }
+
+    private async process(args: Map<string, any>): Promise<void> {
+        let source = args.get("source");
+        if (!source) {
+            Log.errorX(this, "Source filepath is required");
+            return;
+        }
+        let target = args.get("target");
+        if (!target) {
+            Log.errorX(this, "Target filepath is required");
+            return;
+        }
+        let result = await this._analyzer.analyze([source, target]);
+        if (!result) {
+            Log.errorX(this, "Faled to analyze.");
+            return
+        }
+        Log.infoX(this, "Analyzed successfully.");
+
+        let cfgfile = args.get('config');
+        let setResult: boolean = false;
+        if (cfgfile) {
+            let cfg = await JsonReader.instance().readFromFile<ArkCmpCfg>(cfgfile);
+            if (cfg) {
+                this._analyzer.setConfig(cfg);
+                setResult = true;
+            }
+        }
+        if (!setResult) {
+            Log.warnX(this, "No configuration found, use default config.");
+            this._analyzer.setConfig(defaultArkCmpCfg());
+        }
+        console.log(this._analyzer.getConfig());
+        Log.infoX(this, "Set configuration successfully.");
+
+        let sort_type = args.get("sort_type") || 0;
+        let nodeName = args.get("node_name");
+        let outputDir: string = args.get("output") || './output';
+        let outputFileType: string = args.get("output_file") || 'console';
+        Log.infoX(this, `output:${outputDir}; type:${outputFileType}`);
+
+        this.takeAction(sort_type, outputDir, outputFileType, nodeName)
+    }
+
+    private async getOutputCfg(
+        output: IOutput, 
+        outputDesc: any, 
+        outputDir: string, 
+        outputFile: string) : Promise<OutputCfg> { 
+        const analyzerCfg = this._analyzer.getConfig() as ArkCmpCfg;
+        let cfg: OutputCfg = {
+            desc: outputDesc,
+            output: {
+                dir: outputDir,
+                filename: outputFile,
+                extension: output.type.toString(),
+            }
+        }
+        return cfg;
+    }
+
+    private async outputResults(
+        results: Array<any>, 
+        outputEntity: IOutput, 
+        outputCfg: OutputCfg): Promise<void> {
+        if (outputEntity.type === OutputType.CONSOLE) {
+            let data = new ConsoleData(false, results);
+            outputEntity.output(data, outputCfg);
+        } else if (outputEntity.type === OutputType.JSON) {
+            let data = new JsonData(outputCfg.desc, results);
+            outputEntity.output(data, outputCfg);
+        } else if (outputEntity.type === OutputType.TEXT) {
+            let data = new TextData(outputCfg.desc, JSON.stringify(results));
+            outputEntity.output(data, outputCfg);
+        } else if (outputEntity.type === OutputType.HTML) {
+            let data = new HtmlData(outputCfg.desc, JSON.stringify(results));
+            outputEntity.output(data, outputCfg);    
+        } else {
+            Log.errorX(this, 'Invalid output file type.');
+        }
+    }
+
+    private async takeAction(sort_type: number, outputDir:string, output_type: string, node_name?: string): Promise<void> {
+        const analyzer = this._analyzer as ArkCompareAnalyzer;
+        const data_tmp = await analyzer.diffSnapshots(node_name);
+        const results = await analyzer.sortDiffs(sort_type, data_tmp);
+        let outputEntity: IOutput = OutputFactory.getOutput(output_type);
+        let outputCfg = await this.getOutputCfg(outputEntity, undefined, outputDir, '');
+        outputCfg.desc = { 
+            "SourceSnapshot": analyzer.srcSnapshotFilePath, 
+            "TargetSnapshot": analyzer.dstSnapshotFilePath,
+            "Action": "Compare Snapshots",
+            "NodeName": node_name || "None",
+            "Time": Date.now()
+        };
+        this.outputResults(results, outputEntity, outputCfg);
+    }
+}