meminsight-core-publish 1.0.0

package/dist/analyzer/ArkStatCfg.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Ark Statistics Configuration
+ */
+export type ArkStatCfg = {
+    Node: {
+        enableTypeWhiteList: boolean;
+        typeWhiteList: string[];
+        enableTypeBlackList: boolean;
+        typeBlackList: string[];
+        enableNameWhiteList: boolean;
+        nameWhiteList: string[];
+        enableNameBlackList: boolean;
+        nameBlackList: string[];
+        enableId: boolean;
+        enableType: boolean;
+        enableName: boolean;
+        enableSelfSize: boolean;
+        enableRetainedSize: boolean;
+    };
+    Path: {
+        enableDistance: boolean;
+        enableSelfSize: boolean;
+        enableRetainedSize: boolean;
+        enableNativeSize: boolean;
+        enableShortest: boolean;
+        enableShortestLength: boolean;
+        shortestLength: number;
+        enableAggration: boolean;
+        aggrationLength: number;
+        aggrationDescending: boolean;
+        enableMinRetainedSize: boolean;
+        minRetainedSize: number;
+        enableMaxRetainedSize: boolean;
+        maxRetainedSize: number;
+    };
+};
+/**
+ * Ark Statistics default configuration
+ * @returns default configuration
+ */
+export declare function defaultArkStatCfg(): ArkStatCfg;
+//# sourceMappingURL=ArkStatCfg.d.ts.map

package/dist/analyzer/ArkStatCfg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArkStatCfg.d.ts","sourceRoot":"","sources":["../../src/analyzer/ArkStatCfg.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACrB,IAAI,EAAE;QACF,mBAAmB,EAAE,OAAO,CAAC;QAC7B,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,mBAAmB,EAAE,OAAO,CAAC;QAC7B,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,mBAAmB,EAAE,OAAO,CAAC;QAC7B,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,mBAAmB,EAAE,OAAO,CAAC;QAC7B,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,QAAQ,EAAE,OAAO,CAAC;QAClB,UAAU,EAAE,OAAO,CAAC;QACpB,UAAU,EAAE,OAAO,CAAC;QACpB,cAAc,EAAE,OAAO,CAAC;QACxB,kBAAkB,EAAE,OAAO,CAAC;KAC/B,CAAC;IACF,IAAI,EAAE;QACF,cAAc,EAAE,OAAO,CAAC;QACxB,cAAc,EAAE,OAAO,CAAC;QACxB,kBAAkB,EAAE,OAAO,CAAC;QAC5B,gBAAgB,EAAE,OAAO,CAAC;QAC1B,cAAc,EAAE,OAAO,CAAC;QACxB,oBAAoB,EAAE,OAAO,CAAC;QAC9B,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,OAAO,CAAC;QACzB,eAAe,EAAE,MAAM,CAAC;QACxB,mBAAmB,EAAE,OAAO,CAAC;QAC7B,qBAAqB,EAAE,OAAO,CAAC;QAC/B,eAAe,EAAE,MAAM,CAAC;QACxB,qBAAqB,EAAE,OAAO,CAAC;QAC/B,eAAe,EAAE,MAAM,CAAC;KAC3B,CAAA;CACJ,CAAA;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAK,UAAU,CAmC/C"}

package/dist/analyzer/ArkStatCfg.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultArkStatCfg = defaultArkStatCfg;
+/**
+ * Ark Statistics default configuration
+ * @returns default configuration
+ */
+function defaultArkStatCfg() {
+    return {
+        Node: {
+            enableTypeWhiteList: true,
+            typeWhiteList: ["object", "closure", "string", "array"],
+            enableTypeBlackList: false,
+            typeBlackList: [],
+            enableNameWhiteList: false,
+            nameWhiteList: [],
+            enableNameBlackList: false,
+            nameBlackList: [],
+            enableId: true,
+            enableType: true,
+            enableName: true,
+            enableSelfSize: false,
+            enableRetainedSize: false,
+        },
+        Path: {
+            enableDistance: true,
+            enableSelfSize: true,
+            enableRetainedSize: true,
+            enableNativeSize: false,
+            enableShortest: true,
+            enableShortestLength: false,
+            shortestLength: 0,
+            enableAggration: true,
+            aggrationLength: 3,
+            aggrationDescending: true,
+            enableMinRetainedSize: true,
+            minRetainedSize: 1024 * 1024, // 1MB
+            enableMaxRetainedSize: false,
+            maxRetainedSize: 0,
+        },
+    };
+}

package/dist/analyzer/ArkTracePath.d.ts

@@ -0,0 +1,90 @@
+import { IHeapSnapshot, IHeapNode, LeakTracePathItem } from '@memlab/core';
+import { ILoggable } from '../utils/Log';
+/**
+ * ArkTracePathItem
+ */
+export type ArkTracePathItem = LeakTracePathItem;
+/**
+ * ArkNodeTracePath
+ */
+export declare class ArkNodeTracePath {
+    readonly tracePathItem: ArkTracePathItem;
+    readonly uid: string;
+    readonly nodeIds: number[];
+    readonly reverse: boolean;
+    readonly retainedSize: number;
+    constructor(item: ArkTracePathItem, reverse?: boolean);
+    getTracePathInfo(joinStr?: string): string;
+    static getNodeIdTrace(item: ArkTracePathItem): number[];
+    /**
+     * 获取本路径上的节点retained size
+     * @param item
+     * @returns
+     */
+    static getRetainedSize(item: ArkTracePathItem): number;
+}
+/**
+ * ArkNode最短路径uid和最短路径索引关系对象
+ */
+export declare class ArkNodePathIndexes {
+    readonly uid: string;
+    indexes: number[];
+    constructor(uid: string);
+    addIndex(index: number): void;
+    get(filter: (condition: any) => boolean, condition: any): number[];
+}
+/**
+ * ArkNodes
+ */
+export declare class ArkNodes extends Array<number> implements ILoggable {
+    readonly DOMAIN: string;
+    readonly TAG: string;
+    className: string;
+    selfSize: number;
+    retainedSize: number;
+    shortestPaths: ArkNodeTracePath[];
+    aggrationPathIndexes: Map<string, ArkNodePathIndexes>;
+    /**
+     * ArkNodes constructor
+     * @param className node name
+     * @param selfSize node self size
+     * @param retainedSize node retained size
+     */
+    constructor(className: string, selfSize: number, retainedSize: number);
+    /**
+     * add shortest node trace path
+     * @param path shortest node trace path
+     */
+    addShortestPath(path: ArkNodeTracePath): void;
+    /**
+     * add node id
+     * @param nodeId node id
+     */
+    addNodeId(nodeId: number): void;
+    /**
+     * 获取最短路径uid和最短路径索引和引用次数的映射数据
+     * uid = [...node.id].join('->')
+     * @param descending 按引用次数降序排序，否则升序排序
+     * @param maxIndexLength 最大引用路径个数
+     */
+    getAggrationPathIndexes(descending?: boolean, maxIndexLength?: number, minRetainedSize?: number): void;
+    getPathIndexesRetainedSize(uid: string): number;
+}
+/**
+ * ArkNodes Map<nodeName, nodeId array>
+ */
+export declare class ArkNodesMap extends Map<string, ArkNodes> implements ILoggable {
+    DOMAIN: string;
+    TAG: string;
+    constructor();
+    /**
+     * add node to map
+     * @param snapshot heap snapshot
+     * @param node heap node
+     * @param nameWhiteList node names
+     * @param typeWhiteList node types
+     * @param enableShortestPath enable shortest path
+     */
+    addNode(snapshot: IHeapSnapshot, node: IHeapNode, nameWhiteList: string[], typeWhiteList?: string[], enableShortestPath?: boolean): void;
+}
+//# sourceMappingURL=ArkTracePath.d.ts.map

package/dist/analyzer/ArkTracePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArkTracePath.d.ts","sourceRoot":"","sources":["../../src/analyzer/ArkTracePath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAE1E,OAAO,EAAE,SAAS,EAAO,MAAM,cAAc,CAAC;AAE9C;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,CAAC;AAEjD;;GAEG;AACH,qBAAa,gBAAgB;IACzB,SAAgB,aAAa,EAAE,gBAAgB,CAAC;IAChD,SAAgB,GAAG,EAAE,MAAM,CAAC;IAC5B,SAAgB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClC,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,SAAgB,YAAY,EAAE,MAAM,CAAC;gBAEzB,IAAI,EAAE,gBAAgB,EAAE,OAAO,GAAE,OAAe;IAQrD,gBAAgB,CAAC,OAAO,GAAE,MAAe,GAAI,MAAM;WAsB5C,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAI,MAAM,EAAE;IAc/D;;;;OAIG;WACW,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAI,MAAM;CAajE;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC3B,SAAgB,GAAG,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,EAAE,CAAC;gBAEb,GAAG,EAAE,MAAM;IAIhB,QAAQ,CAAC,KAAK,EAAE,MAAM;IAItB,GAAG,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,GAAG,KAAK,OAAO,EAAE,SAAS,EAAE,GAAG;CAKjE;AAED;;GAEG;AACH,qBAAa,QAAS,SAAQ,KAAK,CAAC,MAAM,CAAE,YAAW,SAAS;IAC5D,SAAgB,MAAM,EAAE,MAAM,CAAgB;IAC9C,SAAgB,GAAG,EAAE,MAAM,CAAiB;IACrC,SAAS,EAAE,MAAM,CAAM;IACvB,QAAQ,EAAE,MAAM,CAAK;IACrB,YAAY,EAAE,MAAM,CAAK;IACzB,aAAa,EAAE,gBAAgB,EAAE,CAAC;IAClC,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAE7D;;;;;OAKG;gBACS,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IAOrE;;;OAGG;IACI,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAI,IAAI;IAIrD;;;OAGG;IACI,SAAS,CAAC,MAAM,EAAE,MAAM,GAAI,IAAI;IAIvC;;;;;OAKG;IACI,uBAAuB,CAAC,UAAU,GAAE,OAAc,EACrD,cAAc,GAAE,MAAW,EAAE,eAAe,SAAK,GAAI,IAAI;IAwCtD,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAI,MAAM;CAgB1D;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAE,YAAW,SAAS;IACvE,MAAM,EAAE,MAAM,CAAe;IAC7B,GAAG,EAAE,MAAM,CAAoB;;IAM/B;;;;;;;OAOG;IACI,OAAO,CACV,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,SAAS,EACf,aAAa,EAAE,MAAM,EAAE,EACvB,aAAa,GAAE,MAAM,EAAe,EACpC,kBAAkB,GAAE,OAAc,GAAI,IAAI;CAiCjD"}

package/dist/analyzer/ArkTracePath.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArkNodesMap = exports.ArkNodes = exports.ArkNodePathIndexes = exports.ArkNodeTracePath = void 0;
+const Finder_1 = require("../utils/Finder");
+const Log_1 = require("../utils/Log");
+/**
+ * ArkNodeTracePath
+ */
+class ArkNodeTracePath {
+    constructor(item, reverse = false) {
+        this.tracePathItem = item;
+        this.nodeIds = ArkNodeTracePath.getNodeIdTrace(item);
+        this.retainedSize = ArkNodeTracePath.getRetainedSize(item);
+        this.reverse = reverse;
+        this.uid = reverse ? this.nodeIds.reverse().join('<-') : this.nodeIds.join('->');
+    }
+    getTracePathInfo(joinStr = '===>') {
+        var _a;
+        if (this.nodeIds.length === 0) {
+            return '';
+        }
+        const snapshot = (_a = this.tracePathItem.node) === null || _a === void 0 ? void 0 : _a.snapshot;
+        if (!snapshot) {
+            Log_1.Log.error('meminsight', ArkNodeTracePath.name, 'Failed to get snapshot.');
+            return '';
+        }
+        const result = [];
+        this.nodeIds.forEach(id => {
+            let node = snapshot.getNodeById(id);
+            if (node) {
+                let sizeStr = node.retainedSize >= 1024 * 1024 ?
+                    (node.retainedSize / (1024 * 1024)).toFixed(2) + 'MB' :
+                    (node.retainedSize / 1024).toFixed(2) + 'KB';
+                result.push(`@${id} (${node.type}) [${sizeStr}] ${node.name}`);
+            }
+        });
+        return result.join(`\n${joinStr}`);
+    }
+    static getNodeIdTrace(item) {
+        const nodeIds = [];
+        let curItem = item;
+        while (curItem) {
+            let node = curItem.node;
+            if (!node) {
+                break;
+            }
+            nodeIds.push(node.id);
+            curItem = curItem.next;
+        }
+        return nodeIds;
+    }
+    /**
+     * 获取本路径上的节点retained size
+     * @param item
+     * @returns
+     */
+    static getRetainedSize(item) {
+        let retained = 0;
+        let curItem = item;
+        while (curItem) {
+            let node = curItem.node;
+            if (!node) {
+                break;
+            }
+            retained += node.self_size;
+            curItem = curItem.next;
+        }
+        return retained;
+    }
+}
+exports.ArkNodeTracePath = ArkNodeTracePath;
+/**
+ * ArkNode最短路径uid和最短路径索引关系对象
+ */
+class ArkNodePathIndexes {
+    constructor(uid) {
+        this.uid = uid;
+    }
+    addIndex(index) {
+        this.indexes.push(index);
+    }
+    get(filter, condition) {
+        return this.indexes.filter((index) => {
+            return filter(condition);
+        });
+    }
+}
+exports.ArkNodePathIndexes = ArkNodePathIndexes;
+/**
+ * ArkNodes
+ */
+class ArkNodes extends Array {
+    /**
+     * ArkNodes constructor
+     * @param className node name
+     * @param selfSize node self size
+     * @param retainedSize node retained size
+     */
+    constructor(className, selfSize, retainedSize) {
+        super();
+        this.DOMAIN = 'meminsight';
+        this.TAG = ArkNodes.name;
+        this.className = ''; // node class name
+        this.selfSize = 0; // node total self size
+        this.retainedSize = 0; // node total retained size
+        this.className = className;
+        this.selfSize = selfSize;
+        this.retainedSize = retainedSize;
+    }
+    /**
+     * add shortest node trace path
+     * @param path shortest node trace path
+     */
+    addShortestPath(path) {
+        this.shortestPaths.push(path);
+    }
+    /**
+     * add node id
+     * @param nodeId node id
+     */
+    addNodeId(nodeId) {
+        this.push(nodeId);
+    }
+    /**
+     * 获取最短路径uid和最短路径索引和引用次数的映射数据
+     * uid = [...node.id].join('->')
+     * @param descending 按引用次数降序排序，否则升序排序
+     * @param maxIndexLength 最大引用路径个数
+     */
+    getAggrationPathIndexes(descending = true, maxIndexLength = -1, minRetainedSize = -1) {
+        if (this.shortestPaths.length === 0) {
+            Log_1.Log.warnX(this, 'No shortest path found');
+            return;
+        }
+        const indexes = new Map();
+        this.shortestPaths.forEach((path, index) => {
+            const indexesItem = indexes.get(path.uid);
+            if (!indexesItem) {
+                const pathIndexes = new ArkNodePathIndexes(path.uid);
+                pathIndexes.addIndex(index);
+                indexes.set(path.uid, pathIndexes);
+            }
+            else {
+                indexesItem.addIndex(index);
+            }
+        });
+        const sortedIndexes = descending
+            ? new Map([...indexes.entries()].sort((a, b) => a[1].indexes.length - b[1].indexes.length))
+            : new Map([...indexes.entries()].sort((a, b) => b[1].indexes.length - a[1].indexes.length));
+        if ((maxIndexLength <= 0) || (sortedIndexes.size <= maxIndexLength)) {
+            this.aggrationPathIndexes = sortedIndexes;
+        }
+        else {
+            this.aggrationPathIndexes = new Map([...sortedIndexes.entries()].slice(0, maxIndexLength));
+        }
+        if (minRetainedSize > 0) {
+            this.aggrationPathIndexes.forEach((pathIndexes, uid) => {
+                var _a;
+                const tmpIndexes = [];
+                let idx = pathIndexes.indexes.pop();
+                while (idx) {
+                    let size = ((_a = this.shortestPaths.at(idx)) === null || _a === void 0 ? void 0 : _a.retainedSize) || 0;
+                    if (size >= minRetainedSize) {
+                        tmpIndexes.push(idx);
+                    }
+                    idx = pathIndexes.indexes.pop();
+                }
+                pathIndexes.indexes = tmpIndexes;
+            });
+        }
+    }
+    getPathIndexesRetainedSize(uid) {
+        let pathIndexes = this.aggrationPathIndexes.get(uid);
+        if (!pathIndexes) {
+            return 0;
+        }
+        let preSize = 0;
+        let curSize;
+        return pathIndexes.indexes.reduce((pre, cur) => {
+            var _a;
+            curSize = (_a = this.shortestPaths.at(cur)) === null || _a === void 0 ? void 0 : _a.retainedSize;
+            if (!curSize) {
+                return preSize;
+            }
+            preSize = curSize;
+            return preSize + curSize;
+        }, 0);
+    }
+}
+exports.ArkNodes = ArkNodes;
+/**
+ * ArkNodes Map<nodeName, nodeId array>
+ */
+class ArkNodesMap extends Map {
+    constructor() {
+        super();
+        this.DOMAIN = 'meminsight';
+        this.TAG = ArkNodesMap.name;
+    }
+    /**
+     * add node to map
+     * @param snapshot heap snapshot
+     * @param node heap node
+     * @param nameWhiteList node names
+     * @param typeWhiteList node types
+     * @param enableShortestPath enable shortest path
+     */
+    addNode(snapshot, node, nameWhiteList, typeWhiteList = ['object'], enableShortestPath = true) {
+        // true if names is empty or types include node.type
+        if ((nameWhiteList.length == 0
+            || nameWhiteList.includes(node.name))
+            && typeWhiteList.includes(node.type)) {
+            const arkNodes = this.get(node.name);
+            if (!arkNodes) {
+                let arkNodes = new ArkNodes(node.name, node.self_size, node.retainedSize);
+                if (enableShortestPath) {
+                    const arkTracePathItem = Finder_1.Finder.findShortestPathToGCRoot(snapshot, node);
+                    if (arkTracePathItem) {
+                        arkNodes.addShortestPath(new ArkNodeTracePath(arkTracePathItem));
+                    }
+                    else {
+                        Log_1.Log.errorX(this, 'ArkNodesMap1: Finder.findShortestPathToGCRoot return undefined.');
+                    }
+                }
+                arkNodes.addNodeId(node.id);
+                this.set(node.name, arkNodes);
+            }
+            else {
+                arkNodes.selfSize += node.self_size;
+                arkNodes.retainedSize += node.retainedSize;
+                if (enableShortestPath) {
+                    const arkTracePathItem = Finder_1.Finder.findShortestPathToGCRoot(snapshot, node);
+                    if (arkTracePathItem) {
+                        arkNodes.addShortestPath(new ArkNodeTracePath(arkTracePathItem));
+                    }
+                    else {
+                        Log_1.Log.errorX(this, 'ArkNodesMap2: Finder.findShortestPathToGCRoot return undefined.');
+                    }
+                }
+                arkNodes.addNodeId(node.id);
+            }
+        }
+    }
+}
+exports.ArkNodesMap = ArkNodesMap;

package/dist/analyzer/ArkTracer.d.ts

@@ -0,0 +1,17 @@
+import { ArkTracePathItem } from "./ArkTracePath";
+/**
+ * ArkTracePath Filter function
+ */
+export type ArkTracePathFilter = (condition?: any) => boolean;
+/**
+ * ArkTracePath Output function
+ */
+export type ArkTracePathOutput = (path: ArkTracePathItem, filter?: ArkTracePathFilter, condition?: any) => string;
+/**
+ * ArkTracer
+ */
+export declare class ArkTracer {
+    static outputTracePath(tracePath: ArkTracePathItem, output?: ArkTracePathOutput, filter?: ArkTracePathFilter, condition?: any): void;
+    static getTracePathString(tracePath: ArkTracePathItem, output?: ArkTracePathOutput, filter?: ArkTracePathFilter, condition?: any): string;
+}
+//# sourceMappingURL=ArkTracer.d.ts.map

package/dist/analyzer/ArkTracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArkTracer.d.ts","sourceRoot":"","sources":["../../src/analyzer/ArkTracer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC;AAC9D;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,kBAAkB,EAAE,SAAS,CAAC,EAAE,GAAG,KAAK,MAAM,CAAC;AAOlH;;GAEG;AACH,qBAAa,SAAS;WACJ,eAAe,CACzB,SAAS,EAAE,gBAAgB,EAC3B,MAAM,CAAC,EAAE,kBAAkB,EAC3B,MAAM,CAAC,EAAE,kBAAkB,EAC3B,SAAS,CAAC,EAAE,GAAG,GAAI,IAAI;WASb,kBAAkB,CAC5B,SAAS,EAAE,gBAAgB,EAC3B,MAAM,CAAC,EAAE,kBAAkB,EAC3B,MAAM,CAAC,EAAE,kBAAkB,EAC3B,SAAS,CAAC,EAAE,GAAG,GAAI,MAAM;CAGhC"}

package/dist/analyzer/ArkTracer.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArkTracer = void 0;
+const core_1 = require("@memlab/core");
+const defaultOutput = (path) => {
+    var _a;
+    let snapshot = (_a = path === null || path === void 0 ? void 0 : path.node) === null || _a === void 0 ? void 0 : _a.snapshot;
+    return snapshot ? core_1.serializer.summarizePath(path, new Set(), snapshot, { color: true }) : '';
+};
+/**
+ * ArkTracer
+ */
+class ArkTracer {
+    static outputTracePath(tracePath, output, filter, condition) {
+        let result = output ? output(tracePath, filter, condition) : defaultOutput(tracePath);
+        if (result !== '') {
+            console.log(result);
+        }
+        else {
+            console.log('No leak trace path.');
+        }
+    }
+    static getTracePathString(tracePath, output, filter, condition) {
+        return output ? output(tracePath, filter, condition) : defaultOutput(tracePath);
+    }
+}
+exports.ArkTracer = ArkTracer;

package/dist/analyzer/ArkXAnalyzer.d.ts

@@ -0,0 +1,69 @@
+import { IHeapSnapshot } from "@memlab/core";
+import { ArkAnalyzer } from "./ArkAnalyzer";
+import { ILoggable } from "../utils/Log";
+import { IBaseInfo } from "./AnalysisInfo";
+export declare enum ArkXSortType {
+    BY_RETAINED_SIZE = 0,
+    BY_COUNT = 1
+}
+export type ArkXAnalyzerConfig = {
+    topN: number;
+    sortType: ArkXSortType;
+    tags: string[];
+};
+/**
+ * Ark Heapsnapshot 统计分析器
+ */
+export declare class ArkXAnalyzer extends ArkAnalyzer implements ILoggable {
+    readonly DOMAIN = "meminsight";
+    readonly TAG: string;
+    static readonly NAME = "ark-x-analyzer";
+    static readonly DESC = "Analyze heapsnapshot files and aggregate & statistics.";
+    private snapshotFiles;
+    private config;
+    constructor();
+    setConfig(config: ArkXAnalyzerConfig): void;
+    analyze(args: any[]): Promise<void>;
+    private analyzeOne;
+    /**
+     * 指定类名对象按 Distance 统计
+     */
+    statSpecificObjectNameByDistance(snapshot: IHeapSnapshot, objectName: string): IBaseInfo;
+    /**
+     * 指定类名的最短引用链聚合
+     * @param snapshot 快照
+     * @param topNum TopN
+     */
+    aggregateSpecificObjectNameByReference(snapshot: IHeapSnapshot, objectName: string, topNum?: number): IBaseInfo;
+    /**
+     * 指定类名的Distance=1的对象属性按最短引用链聚合
+     * @param snapshot 快照
+     * @param objectName
+     * @param topNum TopN
+     */
+    aggregateSpecificObjectNameByDistance1(snapshot: IHeapSnapshot, objectName: string, topNum?: number, maxRetainedSize?: number): IBaseInfo;
+    /**
+     * 指定类名的最短引用链聚合
+     * @param snapshot 快照
+     * @param topNum TopN
+     */
+    aggregateSpecificObjectTypeByReference(snapshot: IHeapSnapshot, objectType: string, topNum?: number): IBaseInfo;
+    /**
+     * 指定类名/类型/标签的最短引用链聚合
+     * @param snapshot 快照
+     * @param objectName 对象类名，为空则不判断
+     * @param objectType 对象类型，为空则不判断
+     * @param tags 对象标签，比如业务标签
+     * @param topNum TopN
+     */
+    aggregateSpecificObjectInfoByReference(snapshot: IHeapSnapshot, objectName: string, objectType: string, tags: string[], topNum?: number): IBaseInfo;
+    /**
+     * 指定类名/类型/标签的最短引用链聚合
+     * @param snapshot 快照
+     * @param objectType 对象类型，为空则不判断
+     * @param tags 对象标签，比如业务标签
+     * @param topNum TopN
+     */
+    aggregateSpecificObjectInfoByClassName(snapshot: IHeapSnapshot, objectType: string, tags: string[], topNum?: number): IBaseInfo;
+}
+//# sourceMappingURL=ArkXAnalyzer.d.ts.map

package/dist/analyzer/ArkXAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArkXAnalyzer.d.ts","sourceRoot":"","sources":["../../src/analyzer/ArkXAnalyzer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAwB,MAAM,cAAc,CAAC;AAEnE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAO,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAMH,SAAS,EAKZ,MAAM,gBAAgB,CAAC;AAGxB,oBAAY,YAAY;IACpB,gBAAgB,IAAA;IAChB,QAAQ,IAAA;CACX;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,YAAY,CAAC;IACvB,IAAI,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,qBAAa,YAAa,SAAQ,WAAY,YAAW,SAAS;IAC9D,SAAgB,MAAM,gBAAgB;IACtC,SAAgB,GAAG,SAAqB;IACxC,gBAAuB,IAAI,oBAAoB;IAC/C,gBAAuB,IAAI,4DAA4D;IAEvF,OAAO,CAAC,aAAa,CAAW;IAChC,OAAO,CAAC,MAAM,CAAqB;;IAY5B,SAAS,CAAC,MAAM,EAAE,kBAAkB;IAIrB,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE;YAsD3B,UAAU;IA8DxB;;OAEG;IACI,gCAAgC,CAAC,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS;IAkE/F;;;;OAIG;IACI,sCAAsC,CAAC,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAE,MAAW,GAAG,SAAS;IAqE1H;;;;;OAKG;IACI,sCAAsC,CAAC,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAE,MAAW,EAAE,eAAe,GAAE,MAAW,GAAG,SAAS;IAmFxJ;;;;OAIG;IACI,sCAAsC,CAAC,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAE,MAAW,GAAG,SAAS;IAoE1H;;;;;;;OAOG;IACI,sCAAsC,CAAC,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,GAAE,MAAW,GAAG,SAAS;IAsE9J;;;;;;OAMG;IACI,sCAAsC,CAAC,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,GAAE,MAAW,GAAG,SAAS;CAkE7I"}