meminsight-test-demo 1.0.0

package/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "meminsight-test-demo",
+    "version": "1.0.0",
+    "description": "meminsight for memory analysis.",
+    "type": "module",
+    "dependencies": {
+        "commander": "^13.1.0",
+        "fs-extra": "^11.2.1",
+        "moment": "^2.29.4",
+        "winston": "^3.11.0"
+    },
+    "devDependencies": {
+        "@babel/cli": "^7.27.2",
+        "@babel/core": "^7.27.1",
+        "@babel/preset-env": "^7.27.2",
+        "@types/blessed": "^0.1.19",
+        "@types/fs-extra": "^11.0.4",
+        "@types/jest": "^29.1.1",
+        "@types/node": "^22.15.17",
+        "jest": "^29.1.1",
+        "ts-jest": "^29.1.1",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.8.3"
+    },
+    "workspaces": [
+        "./packages/core",
+        "./packages/meminsight",
+        "./packages/exampletools"
+    ],
+    "scripts": {
+        "dev": "tsc -b -w",
+        "build": "npm run clean && npm run build --workspaces",
+        "test": "npm run test --workspaces --if-present",
+        "publish": "npm run publish-patch --workspaces",
+        "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo && npm run clean --workspaces",
+        "clean-all": "npm run clean-all --workspaces && rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo && rm -rf ./node_modules && rm -rf ./output",
+        "pkg-meminsight": "pkg -t node18 --output=./dist/meminsight --public -C GZip packages/meminsight/package.json",
+        "pkg-exampletools": "pkg -t node18 --output=./dist/exampletools --public -C GZip packages/exampletools/package.json"
+    },
+    "devEngines": {
+        "node": "16.x | 18.x | 20.x | 22.x",
+        "npm": "7.x"
+    },
+    "pkg": {
+        "scripts": {
+            "postinstall": "npm run build"
+        },
+        "assets": [
+            "dist/**/*",
+            "packages/**/package.json"
+        ],
+        "output": "dist"
+    }
+}

package/packages/cfg/ArkStatCfg.json

@@ -0,0 +1,33 @@
+{
+    "Node": {
+        "enableTypeWhiteList": true,
+        "typeWhiteList": ["object", "closure"],
+        "enableTypeBlackList": false,
+        "typeBlackList": [],
+        "enableNameWhiteList": false,
+        "nameWhiteList": [],
+        "enableNameBlackList": true,
+        "nameBlackList": [],
+        "enableId": true,
+        "enableType": true,
+        "enableName": true,
+        "enableSelfSize": true,
+        "enableRetainedSize": true
+    },
+    "Path": {
+        "enableDistance": true,
+        "enableSelfSize": true,
+        "enableRetainedSize": true,
+        "enableNativeSize": false,
+        "enableShortest": true,
+        "enableShortestLength": false,
+        "shortestLength": 0,
+        "enableAggration": true,
+        "aggrationLength": 3,
+        "aggrationDescending": true,
+        "enableMinRetainedSize": true,
+        "minRetainedSize": 1048576,
+        "enableMaxRetainedSize": false,
+        "maxRetainedSize": 0
+    }
+}

package/packages/core/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/core/package.json

@@ -0,0 +1,61 @@
+{
+    "name": "@meminsight/core",
+    "version": "1.0.0",
+    "description": "meminsight core library is for memory analysis.",
+    "author": { 
+        "name": ""
+    },
+    "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",
+    "types": "dist/Index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/Index.d.ts",
+            "default": "./dist/Index.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "files": [
+        "./dist",
+        "License"
+    ],
+    "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": []
+}

package/packages/core/src/Index.ts

@@ -0,0 +1,53 @@
+// types
+export { 
+    IDataInfo, 
+    AppInfo, 
+    DeviceInfo, 
+    HeapFileInfo, 
+    HeapInfos, 
+    OsInfo, 
+    UrlInfo 
+} from './types/OhosTypes';
+
+// utils
+export { ILogger, ILoggable, Log, LogType } from './utils/Log';
+export { Loader } from './utils/Loader';
+export { Finder } from './utils/Finder';
+export {
+    IOutput,
+    OutputType,
+    OutputCfg,
+    OutputFactory,
+    ConsoleData,
+    ConsoleTableData,
+    TextData,
+    JsonData,
+    HtmlData
+} from './utils/Output';
+
+// file
+export { IReader, BaseReader, JsonReader } from './file/FileReader';
+export { IWriter, BaseWriter, TextWriter, JsonWriter, HtmlWriter } from './file/FileWriter';
+
+// analyzer
+export { IAnalyzer } from './analyzer/IAnalyzer';
+export { ArkAnalyzer } from './analyzer/ArkAnalyzer';
+export { ArkStatAnalyzer } from './analyzer/ArkStatAnalyzer';
+export { ArkCompareAnalyzer } from './analyzer/ArkCompareAnalyzer';
+export { ArkLeakAnalyzer } from './analyzer/ArkLeakAnalyzer';
+export { ArkStatCfg, defaultArkStatCfg } from './analyzer/ArkStatCfg';
+export { ArkCmpCfg, defaultArkCmpCfg } from './analyzer/ArkCmpCfg';
+export { ArkXAnalyzer } from './analyzer/ArkXAnalyzer';
+export { 
+    ArkTracePathItem, 
+    ArkNodeTracePath, 
+    ArkNodePathIndexes, 
+    ArkNodes, 
+    ArkNodesMap
+} from './analyzer/ArkTracePath';
+export { ArkTracer, ArkTracePathFilter, ArkTracePathOutput } from './analyzer/ArkTracer';
+export { ArkSerializer } from './analyzer/ArkSerializer';
+
+// shell
+export { IShell, ShellArgs, Shell } from './shell/Shell';
+export { DeviceShell } from './shell/DeviceShell';

package/packages/core/src/analyzer/AnalysisInfo.ts

@@ -0,0 +1,298 @@
+import { ReportData } from "../report/Reporter";
+
+export interface IBaseInfo {
+    toReportData: () => ReportData;
+}
+
+export class ClassInfo {
+  public className: string;         // 指定类名
+  public count: number;             // 指定类总数量
+  public retainedSize: number;      // 指定类总retainedSize
+  public selfSize: number;          // 指定类总selfSize
+  public retainedSizeTotalHeapPercent: number;      // 指定类总retainedSize占TotalHeapSize百分比
+  public selfSizeTotalHeapPercent: number;          // 指定类总selfSize占TotalHeapSize百分比
+  public retainedSizeTotalRetainedPercent: number;  // 指定类总retainedSize占TotalRetainedSize百分比
+  public selfSizeTotalSelfPercent: number;          // 指定类总selfSize占TotalSelfSize百分比
+
+  toString(): string {
+    return `Class Name: ${this.className},
+    Count: ${this.count}, 
+    Retained Size: ${(this.retainedSize / 1024).toFixed(2)} KB, 
+    RetainedSizeTotalHeapPercent: ${this.retainedSizeTotalHeapPercent.toFixed(2)}%,
+    Shallow Size: ${(this.selfSize / 1024).toFixed(2)} KB, 
+    ShallowSizeTotalHeapPercent: ${this.selfSizeTotalHeapPercent.toFixed(2)}%`
+  }
+};
+
+export class DistanceInfo {
+  public objectNameOrType: string;// 对象名称或类型
+  public distance: number;        // 最短引用链某一类Distance
+  public count: number;           // 该类Distance总数量
+  public retainedSize: number;    // 该类Distance总retainedSize
+  public selfSize: number;        // 该类Distance总selfSize
+  public retainedSizeTotalHeapPercent: number;      // 该类Distance总retainedSize占TotalHeapSize百分比
+  public selfSizeTotalHeapPercent: number;          // 该类Distance总selfSize占TotalHeapSize百分比
+  public retainedSizeTotalRetainedPercent: number;  // 该类Distance总retainedSize占TotalRetainedSize百分比
+  public selfSizeTotalSelfPercent: number;          // 该类Distance总selfSize占TotalSelfSize百分比
+
+  toString(): string {
+    return `Distance: ${this.distance},
+    Count: ${this.count}, 
+    Retained Size: ${(this.retainedSize / 1024).toFixed(2)} KB, 
+    RetainedSizeTotalHeapPercent: ${this.retainedSizeTotalHeapPercent.toFixed(2)}%,
+    Shallow Size: ${(this.selfSize / 1024).toFixed(2)} KB, 
+    ShallowSizeTotalHeapPercent: ${this.selfSizeTotalHeapPercent.toFixed(2)}%`
+  }
+}
+
+export class ShortestPathInfo {
+  public shortestPathStr: string;        // 最短引用链节点名称
+  public shortestPathIds: number[];      // 最短引用链节点Id
+  public count: number;                  // 相同最短引用链数量
+  public retainedSize: number;           // 相同最短引用链总保留大小
+  public selfSize: number;               // 相同最短引用链总selfSize
+  public retainedSizeTotalHeapPercent: number;      // 该类Distance总retainedSize占TotalHeapSize百分比
+  public selfSizeTotalHeapPercent: number;          // 该类Distance总selfSize占TotalHeapSize百分比
+  public retainedSizeTotalRetainedPercent: number;  // 该类Distance总retainedSize占TotalRetainedSize百分比
+  public selfSizeTotalSelfPercent: number;          // 该类Distance总selfSize占TotalSelfSize百分比
+
+  toString(): string {
+    return `ShortestPath: ${this.shortestPathStr},
+    Count: ${this.count}, 
+    Retained Size: ${(this.retainedSize / 1024).toFixed(2)} KB, 
+    RetainedSizeTotalHeapPercent: ${this.retainedSizeTotalHeapPercent.toFixed(2)}%,
+    Shallow Size: ${(this.selfSize / 1024).toFixed(2)} KB, 
+    ShallowSizeTotalHeapPercent: ${this.selfSizeTotalHeapPercent.toFixed(2)}%`
+  }
+}
+
+export class PropertyInfo {
+  public propName: string;                // 属性名
+  public propShortestPath: string;        // 属性最短引用链
+  public count: number;                   // 该属性总数量
+  public retainedSize: number;            // 该属性总retainedSize
+  public selfSize: number;                // 该属性总selfSize
+  public retainedSizeTotalHeapPercent: number;      // 该属性总retainedSize占TotalHeapSize百分比
+  public selfSizeTotalHeapPercent: number;          // 该属性总selfSize占TotalHeapSize百分比
+  public retainedSizeTotalRetainedPercent: number;  // 该属性总retainedSize占TotalRetainedSize百分比
+  public selfSizeTotalSelfPercent: number;          // 该该属性总selfSize占TotalRetainedSize百分比
+
+  toString(): string {
+    return `Property Name: ${this.propName || ''},
+    Property ShortestPath: ${this.propShortestPath || ''},
+    Count: ${this.count}, 
+    Retained Size: ${(this.retainedSize / 1024).toFixed(2)} KB, 
+    RetainedSizeTotalHeapPercent: ${this.retainedSizeTotalHeapPercent.toFixed(2)}%,
+    Shallow Size: ${(this.selfSize / 1024).toFixed(2)} KB, 
+    ShallowSizeTotalHeapPercent: ${this.selfSizeTotalHeapPercent.toFixed(2)}%`
+  }
+}
+
+/**
+ * 分析数据节点
+ */
+abstract class BaseAnalysisInfo implements IBaseInfo {
+    public name: string;   // 名称信息：分析数据节点名称
+    public type: string;   // 类型信息：js_shared_object | JSObject | JSFunction | framework | global_env ...
+    public desc: string;   // 描述信息：分析数据节点描述
+    public scope: string;  // 范围信息：aggregation | statistics
+
+    public totalHeapSize: number;
+    public totalRetainedSize?: number;
+    public totalSelfSize?: number;
+    public totalCount?: number;
+
+    public className?: string;
+    public classInfos?: ClassInfo[];
+    public distanceInfos?: DistanceInfo[];
+    public shortestPathInfos?: ShortestPathInfo[];
+    public propertyInfos?: PropertyInfo[];
+
+    protected getFeature() : string {
+        return `${this.type} ${this.desc}`;
+    }
+
+    protected getMessage() : string[] {
+        return [
+            `Total Heap Size: ${(this.totalHeapSize / 1024 / 1024).toFixed(2)} MB`,
+            `All ${this.type} Retained Size: ${(this.totalRetainedSize!! / 1024).toFixed(2)} KB`,
+            `All ${this.type} Shallow Size: ${(this.totalSelfSize!! / 1024).toFixed(2)} KB`,
+            `Count of ${this.type}: ${this.totalCount}`
+        ];
+    }
+
+    protected getColumns(): Map<string, string> {
+        return new Map();
+    }
+
+    protected getData() : Record<string, any> {
+        return []
+    }
+
+    toReportData(): ReportData {
+        return {
+            feature: this.getFeature(),
+            messages: this.getMessage(),
+            columns: this.getColumns(),
+            data: this.getData()
+        } as ReportData;
+    }
+}
+
+/**
+ * 按类名聚合分析数据节点信息
+ */
+export class AggregationByClassName extends BaseAnalysisInfo {
+    public name: string = AggregationByClassName.name;
+    public desc: string = "按类名聚合";
+
+    protected getColumns(): Map<string, string> {
+        return new Map([
+            ['className', 'Class Name'],
+            ['count', 'Count'],
+            ['retainedSize', 'Retained Size(KB)'],
+            ['selfSize', 'Shallow Size(KB)'],
+            ['retainedSizeTotalHeapPercent', 'Retained Size Ratio(%)'],
+            ['selfSizeTotalHeapPercent', 'Shallow Size Ratio(%)']
+        ]);
+    }
+
+    protected getData(): Record<string, any> {
+        let data: Record<string, any> = [];
+        this.classInfos?.forEach(info => {
+            data.push({
+                ...info,
+                retainedSize: `${(info.retainedSize / 1024).toFixed(2)}KB`,
+                selfSize: `${(info.selfSize / 1024).toFixed(2)}KB`,
+                retainedSizeTotalHeapPercent: `${(info.retainedSizeTotalHeapPercent).toFixed(2)}%`,
+                selfSizeTotalHeapPercent: `${(info.selfSizeTotalHeapPercent).toFixed(2)}%`
+            });
+        })
+        return data;
+    }
+}
+
+/**
+ * 按最短引用链聚合分析数据节点信息
+ */
+export class AggregationByShortestPath extends BaseAnalysisInfo {
+    public name: string = AggregationByShortestPath.name;
+    public desc: string = "按最短引用链聚合";
+
+    protected getColumns(): Map<string, string> {
+        return new Map([
+            ['shortestPathStr', 'Shortest Path To GCRoot'],
+            ['count', 'Count'],
+            ['retainedSize', 'Retained Size (KB)'],
+            ['selfSize', 'Shallow Size (KB)'],
+            ['retainedSizeTotalHeapPercent', 'Retained Size Ratio(%)'],
+            ['selfSizeTotalHeapPercent', 'Shallow Size Ratio(%)']
+        ]);
+    }
+
+    protected getData(): Record<string, any> {
+        let data: Record<string, any> = [];
+        this.shortestPathInfos?.forEach(info => {
+            data.push({
+                ...info,
+                retainedSize: `${(info.retainedSize / 1024).toFixed(2)}KB`,
+                selfSize: `${(info.selfSize / 1024).toFixed(2)}KB`,
+                retainedSizeTotalHeapPercent: `${(info.retainedSizeTotalHeapPercent).toFixed(2)}%`,
+                selfSizeTotalHeapPercent: `${(info.selfSizeTotalHeapPercent).toFixed(2)}%`,
+            });
+        })
+        return data;
+    }
+}
+
+export class AggregationByProperty extends BaseAnalysisInfo {
+    public name: string = AggregationByProperty.name;
+    public desc: string = "按属性最短引用路径聚合";
+
+     protected getColumns(): Map<string, string> {
+        return new Map([
+            ['propName', 'Property Name'],
+            ['propShortestPath', 'Property Shortest Path To GCRoot'],
+            ['count', 'Count'],
+            ['retainedSize', 'Retained Size(KB)'],
+            ['selfSize', 'Shallow Size(KB)'],
+            ['retainedSizeTotalHeapPercent', 'Retained Size Ratio(%)'],
+            ['selfSizeTotalHeapPercent', 'Shallow Size Ratio(%)'],
+        ]);
+    }
+
+    protected getData(): Record<string, any> {
+        let data: Record<string, any> = [];
+        this.propertyInfos?.forEach(info => {
+            // 处理百分比数据与size数据
+            data.push({
+                ...info,
+                retainedSize: `${(info.retainedSize / 1024).toFixed(2)}KB`,
+                selfSize: `${(info.selfSize / 1024).toFixed(2)}KB`,
+                retainedSizeTotalHeapPercent: `${(info.retainedSizeTotalHeapPercent).toFixed(2)}%`,
+                selfSizeTotalHeapPercent: `${(info.selfSizeTotalHeapPercent).toFixed(2)}%`,
+            });
+        })
+        return data;
+    }
+}
+
+export class StatisticsByClassName extends BaseAnalysisInfo {
+    public name: string = StatisticsByClassName.name;
+    public desc: string = "按类名统计";
+
+    protected getColumns(): Map<string, string> {
+        return new Map([
+            ['className', 'Class Name'],
+            ['count', 'Count'],
+            ['retainedSize', 'Retained Size(KB)'],
+            ['selfSize', 'Shallow Size(KB)'],
+            ['retainedSizeTotalHeapPercent', 'Retained Size Ratio(%)'],
+            ['selfSizeTotalHeapPercent', 'Shallow Size Ratio(%)'],
+        ]);
+    }
+
+    protected getData(): Record<string, any> {
+        let data: Record<string, any> = [];
+        this.distanceInfos?.forEach(info => {
+            data.push({
+                ...info,
+                retainedSize: `${(info.retainedSize / 1024).toFixed(2)}KB`,
+                selfSize: `${(info.selfSize / 1024).toFixed(2)}KB`,
+                retainedSizeTotalHeapPercent: `${(info.retainedSizeTotalHeapPercent).toFixed(2)}%`,
+                selfSizeTotalHeapPercent: `${(info.selfSizeTotalHeapPercent).toFixed(2)}%`,
+            });
+        })
+        return data;
+    }
+}
+
+export class StatisticsByDistance extends BaseAnalysisInfo {
+    public name: string = StatisticsByDistance.name;
+    public desc: string = "按距离统计";
+
+    protected getColumns(): Map<string, string> {
+        return new Map([
+            ['distance', 'Distance'],
+            ['count', 'Count'],
+            ['retainedSize', 'Retained Size(KB)'],
+            ['selfSize', 'Shallow Size(KB)'],
+            ['retainedSizeTotalHeapPercent', 'Retained Size Ratio(%)'],
+            ['selfSizeTotalHeapPercent', 'Shallow Size Ratio(%)'],
+        ]);
+    }
+
+    protected getData(): Record<string, any> {
+        let data: Record<string, any> = [];
+        this.distanceInfos?.forEach(info => {
+            data.push({
+                ...info,
+                retainedSize: `${(info.retainedSize / 1024).toFixed(2)}KB`,
+                selfSize: `${(info.selfSize / 1024).toFixed(2)}KB`,
+                retainedSizeTotalHeapPercent: `${(info.retainedSizeTotalHeapPercent).toFixed(2)}%`,
+                selfSizeTotalHeapPercent: `${(info.selfSizeTotalHeapPercent).toFixed(2)}%`,
+            });
+        })
+        return data;
+    }
+}

package/packages/core/src/analyzer/ArkAnalyzer.ts

@@ -0,0 +1,42 @@
+import { IAnalyzer } from "./IAnalyzer";
+
+/**
+ * Ark 分析器
+ */
+export abstract class ArkAnalyzer implements IAnalyzer {
+    protected type: string = 'ark-analyzer';
+    protected configuration: any;
+
+    /**
+     * 解析
+     * @param args 解析参数
+     * @returns 
+     */
+    public async analyze(args: any[]) : Promise<any> {
+        return undefined;
+    }
+
+    /**
+     * 设置解析器配置
+     * @param cfg 解析器配置
+     */
+    public setConfig(cfg: any) : void {
+        this.configuration = cfg
+    }
+
+    /**
+     * 获取解析器配置
+     * @returns 解析器配置
+     */
+    public getConfig(): any {
+        return this.configuration;
+    }
+
+    /**
+     * 获取解析器类型
+     * @returns 解析器类型
+     */
+    public getType(): string {
+        return this.type;
+    }
+}

package/packages/core/src/analyzer/ArkCmpCfg.ts

@@ -0,0 +1,22 @@
+/**
+ * Ark Compare Configuration
+ */
+export type ArkCmpCfg = {
+    Node: {
+        enableNameWhiteList: boolean,
+        nameWhiteList: string[]
+    }
+}
+
+/**
+ * Ark Compare default configuration
+ * @returns default configuration
+ */
+export function defaultArkCmpCfg() : ArkCmpCfg {
+    return {
+        Node: {
+            enableNameWhiteList: false,
+            nameWhiteList: []
+        }
+    }
+}