meminsight-test-demo 1.0.0

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

@@ -0,0 +1,390 @@
+import {
+    IHeapSnapshot, 
+    IHeapNode, 
+    IHeapEdge,
+    Nullable, 
+    TraceFinder,
+    LeakTracePathItem 
+} from "@memlab/core";
+
+/**
+ * 查找器
+ */
+export class Finder {
+    private static traceFinder: TraceFinder = new TraceFinder();
+
+    /**
+     * 判断是否是指定名称属性的边
+     * @param edge 边
+     * @param propName 名称
+     * @returns true/false
+     */
+    public static isPropEdgeWithName(edge: IHeapEdge, propName: string) : boolean {
+        return edge.type === 'property' && edge.name_or_index === propName;
+    }
+
+    /**
+     * 判断是否是Proto属性的边
+     * @param edge 边
+     * @returns true/false
+     */ 
+    public static isProtoPropEdge(edge: IHeapEdge) {
+        return edge.type === 'property' && edge.name_or_index === 'Proto';
+    }
+
+    /**
+     * 判断是否是hclass属性的边
+     * @param edge 边
+     * @returns true/false
+     */ 
+    public static isHClassPropEdge(edge: IHeapEdge) {
+        return edge.type === 'property' && edge.name_or_index === 'hclass';
+    }
+
+    /**
+     * 共享内存类型
+     * 例举关键类型
+     */
+    public static OOM_SHARED_TYPES: string[] = [
+        'js_shared_object',
+        'js_shared_array',
+        'js_shared_map',
+        'js_shared_set'
+    ];
+
+    public static STRING_UNIQUE_ID = 'shared_heap_string_unique_id_0123456789';
+
+    public static isSharedHeapNode(node: IHeapNode) : boolean {
+        // String 类对象属于 shared heap
+        if (node.isString) {
+            return true
+        }
+        // 共享内存类型与节点名称匹配的
+        if (Finder.OOM_SHARED_TYPES.includes(node.name)) {
+            return true
+        }
+        // 先判断 Proto
+        let protoEdge = node.findAnyReference((edge: IHeapEdge) => { return Finder.isProtoPropEdge(edge) })
+        if (protoEdge) {
+            // 通过 proto 查找是否是 shared heap
+            if (this.OOM_SHARED_TYPES.includes(protoEdge.toNode.name)) {
+                return true
+            }
+            return this.isSharedHeapNode(protoEdge.toNode)
+        }
+        // 再判断 hclass
+        let hclassEdge = node.findAnyReference((edge: IHeapEdge) => { return this.isHClassPropEdge(edge) })
+        if (hclassEdge === null) {
+            return false
+        }
+        return this.isSharedHeapNode(hclassEdge.toNode)
+    }
+
+    public static getSharedHeapNodesMap(snapshot: IHeapSnapshot) : Map<string, Array<IHeapNode>> { 
+        let nodesMap = new Map<string, Array<IHeapNode>>();
+        snapshot.nodes.forEach((node: IHeapNode, ) => {
+            if (Finder.isSharedHeapNode(node)) {
+                let tag = node.isString ? Finder.STRING_UNIQUE_ID : node.name;
+                let nodes = nodesMap.get(tag);
+                if (nodes === undefined) {
+                    nodes = new Array<IHeapNode>();
+                } 
+                nodes.push(node);
+                nodesMap.set(tag, nodes);
+            }
+        });
+        return nodesMap;
+    }
+
+    /**
+     * 获取所有shared heap节点的retained size大小总和
+     * @param snapshot heapsnapshot
+     */
+    public static getSharedHeapNodeRetainedSize(snapshot: IHeapSnapshot) : number { 
+        let retained_size = 0;
+        snapshot.nodes.forEach((node: IHeapNode, ) => {
+            if (Finder.isSharedHeapNode(node)) {
+                retained_size += node.retainedSize;
+            }
+        });
+        return retained_size;
+    }
+
+    /**
+     * 获取所有string类型对象的retained size大小总和
+     * @param snapshot heapsnapshot
+     * @returns retained size of shared heap string
+     */
+    public static getStringRetainedSize(snapshot: IHeapSnapshot) : number {
+        let retained_size = 0;
+        snapshot.nodes.forEach((node: IHeapNode, ) => {
+            if (node.isString) {
+                retained_size += node.retainedSize;
+            }
+        });
+        return retained_size;
+    }
+    
+    public static isSharedHeapNodeId(snapshot: IHeapSnapshot, nodeId: number) : boolean {
+        const node = snapshot.getNodeById(nodeId)
+        if (node === null) {
+            return false
+        }   
+        return Finder.isSharedHeapNode(node)
+    }
+
+    /**
+     * 是否是GCRoot节点
+     * @param node 目标节点
+     * @returns true/false
+     */
+    public static isGCRoot(targetNode: IHeapNode): boolean {
+        return targetNode.numOfReferrers === 0;
+    }
+
+    /**
+     * 是否是Distance为1的节点
+     * @param targetNode 目标节点
+     * @returns true/false
+     */
+    public static isEqualDistanceOne(targetNode: IHeapNode): boolean {
+        let result = false;
+        targetNode.pathEdge
+        targetNode.referrers.forEach((referrer: IHeapEdge) => {
+            if (referrer.fromNode.numOfReferrers === 0) {
+                result = true;
+            }
+        });
+        return result;
+    }
+
+    /**
+     * 查找指定ID的节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeId 节点ID
+     * @returns 
+     */
+    public static findNodeById(snapshot: IHeapSnapshot, nodeId: number) : Nullable<IHeapNode> {
+        return snapshot.getNodeById(nodeId);
+    }
+
+    /**
+     * 查找满足过滤条件的节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param filter 过滤器
+     * @returns IHeapNode Array
+     */
+    public static findNodesByFilter(snapshot: IHeapSnapshot, filter: (node: IHeapNode) => boolean) : Array<IHeapNode> {
+        const result = new Array<IHeapNode>();
+        snapshot.nodes.forEach((node: IHeapNode, ) => {
+            if (filter(node)) {
+                result.push(node);
+            }
+        });
+        return result;
+    }
+
+    /**
+     * 按过滤器和过滤条件查找节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param filter 过滤器
+     * @param condition 过滤条件
+     * @returns IHeapNode Array
+     */
+    public static findNodesByFilterCondition(snapshot: IHeapSnapshot, 
+        filter: (node: IHeapNode, condition: any) => boolean, condition: any) : Array<IHeapNode> {
+        const result = new Array<IHeapNode>();
+        snapshot.nodes.forEach((node: IHeapNode, ) => {
+            if (filter(node, condition)) {
+                result.push(node);
+            }
+        });
+        return result;
+    }
+
+    /**
+     * 查找所有GCRoot节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @returns IHeapNode Array
+     */
+    public static findGCRoots(snapshot: IHeapSnapshot) : Array<IHeapNode> {
+        let filter = (node: IHeapNode) => Finder.isGCRoot(node);
+        return Finder.findNodesByFilter(snapshot, filter);
+    }
+
+    /**
+     * 查找Detached节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @returns IHeapNode Array
+     */
+    public static findDetachedNodes(snapshot: IHeapSnapshot) : Array<IHeapNode> {
+        let filter = (node: IHeapNode) => node.is_detached;
+        return Finder.findNodesByFilter(snapshot, filter);
+    }
+
+    /**
+     * 查找指定个数的Detached节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @returns IHeapNode Array
+     */
+    public static findDetachedNodesByName(snapshot: IHeapSnapshot, nodeName: string) : Array<IHeapNode> {
+        const result = new Array<IHeapNode>();
+        snapshot.nodes.forEach((node: IHeapNode, ) => {
+            if (node.is_detached && node.name === nodeName) {
+                result.push(node);
+            }
+        });
+        return result;
+    }
+
+    /**
+     * find nodes by distance from gc root
+     * @param snapshot snapshot
+     * @param distance distance <= 1
+     * @returns Array<IHeapNode>
+     */
+    public static findNodesByDistanceOne(snapshot: IHeapSnapshot, includeGCRoot: boolean = false) : Array<IHeapNode> {
+        let filter = (node: IHeapNode) => {
+            return (includeGCRoot && Finder.isGCRoot(node)) || Finder.isEqualDistanceOne(node);
+        };
+        return Finder.findNodesByFilter(snapshot, filter);
+    }
+
+    /**
+     * 查找指定节点名称的节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @returns IHeapNode Array
+     */
+    public static findNodesByName(snapshot: IHeapSnapshot, nodeName: string) : Array<IHeapNode> {
+        let filter = (node: IHeapNode) => {
+            return node.name == nodeName;
+        };
+         return Finder.findNodesByFilter(snapshot, filter);
+    }
+
+    /**
+     * 查找指定节点名称的节点，最大个数为
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @param count 查找对象个数（按节点id号排序）
+     * @param reverse 是否倒序查找
+     * @returns IHeapNode Array
+     */
+     public static findNodesByNameCount(
+        snapshot: IHeapSnapshot, 
+        nodeName: string, 
+        count: number) : Array<IHeapNode> { 
+        const result = new Array<IHeapNode>();
+        let nodeCount = 0;
+        snapshot.nodes.forEach((node, )=> {
+            if((node.name == nodeName) && (nodeCount < count)) {
+                result.push(node);
+                nodeCount += 1;
+            }
+        });
+        return result; 
+    }
+
+    /**
+     * 
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @returns 
+     */
+    public static findNodesByNameDistanceOne(snapshot: IHeapSnapshot, nodeName: string, includeGCRoot: boolean = false) : Array<IHeapNode> {
+        let filter = (node: IHeapNode) => {
+            return (node.name === nodeName) 
+                && ((includeGCRoot && Finder.isGCRoot(node)) || Finder.isEqualDistanceOne(node));
+        };
+        return Finder.findNodesByFilter(snapshot, filter);
+    }
+
+    /**
+     * 查找指定节点的最短引用路径
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param targetNode 节点对象
+     * @returns 引用链路径
+     */
+    public static findShortestPathToGCRoot(snapshot: IHeapSnapshot, targetNode: IHeapNode): LeakTracePathItem | undefined {
+        Finder.traceFinder.annotateShortestPaths(snapshot);  // 标记最短路径
+        const optPath = Finder.traceFinder.getPathToGCRoots(snapshot, targetNode);
+        return optPath ? optPath : undefined;
+    }
+
+    /**
+     * 查找指定节点数组的所有最短引用路径
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param targetNodes 节点对象数组
+     * @returns 引用链路径数组
+     */
+    public static findShortestPaths(snapshot: IHeapSnapshot, targetNodes: IHeapNode[]): Array<LeakTracePathItem> {
+        const result: Array<LeakTracePathItem> = new Array<LeakTracePathItem>();
+        Finder.traceFinder.annotateShortestPaths(snapshot);
+        targetNodes.forEach(node => {
+            const optPath = Finder.traceFinder.getPathToGCRoots(snapshot, node);
+            if (optPath) {
+                result.push(optPath);
+            }
+        });
+        return result;
+    }
+
+    /**
+    * 获取堆节点的最短路径
+    * @param node 堆节点
+    * @returns 最短路径的节点名称数组
+    * @example
+    */
+    public static getShortestPath(node: IHeapNode): [number[], string[], number] {
+        const shortestPathNodeIds: number[] = []
+        const shortestPathStrings: string[] = []
+        let distance = 0;
+        let shortestPathNode = node
+        while (shortestPathNode && shortestPathNode.hasPathEdge) {
+            let edge = shortestPathNode.pathEdge
+            if (edge) {
+                distance++;
+                shortestPathNodeIds.push(edge.fromNode.id);
+                shortestPathStrings.push(edge.fromNode.name);
+                shortestPathNode = edge.fromNode
+            }
+        }
+        return [shortestPathNodeIds, shortestPathStrings, distance];
+    }
+
+       /**
+     * 获取节点模块名（兼容5.x & 6.0）
+     * @param name 节点名称
+     * @returns module name
+     */
+    public static getModuleName(name: string): string {
+        let nameSplit = name.split('#');
+        if (nameSplit.length > 1) {
+            // 6.0
+            return nameSplit[0];
+        }
+        // 5.x
+        return name.split(' ')[0];
+    }
+
+    /**
+     * 获取节点Class名（兼容5.x & 6.0）
+     * @param name 节点名称
+     * @returns class name
+     */
+    public static getClassName(name: string): string {
+        let regex = /^(.*?)\(line:\d+\).*?$/;
+        const match = regex.exec(name);
+        if (match) {
+            return match[1];
+        }
+        let regex5 = /^(.*?)\(.*?\)$/;
+        const match5 = regex5.exec(name);
+        if (match5) {
+            return match5[1]
+        }
+        return name;
+    }
+}

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

@@ -0,0 +1,53 @@
+import { IHeapSnapshot, utils, AnyOptions } from "@memlab/core";
+import { getFullHeapFromFile } from "@memlab/heap-analysis";
+import { Log } from "../utils/Log";
+
+/**
+ * Loader
+ */
+export class Loader {
+    public static readonly DOMAIN = 'HeapSnapshot';
+    public static readonly TAG = 'Loader';
+
+    /**
+     * 加载HeapSnapshot文件
+     * @param file 文件路径
+     * @param log 是否打印日志
+     * @returns IHeapSnapshot 对象
+     */
+    public static async loadFromFile(file: string, log: boolean = false) : Promise<IHeapSnapshot> {
+        if (log) Log.info(Loader.DOMAIN, Loader.TAG, `Loading heapsnapshot from file: ${file}`);
+        const snapshot = await getFullHeapFromFile(file);
+        if (log) Log.info(Loader.DOMAIN, Loader.TAG, `Loaded heapsnapshot from file: ${file}`);         
+        return snapshot;
+    }
+
+    /**
+     * 加载HeapSnapshot文件
+     * @param file 文件路径
+     * @param options 可选参数选项
+     * @param log 是否打印日志
+     * @returns IHeapSnapshot 对象
+     */
+    public static async loadFromFileOption(file: string, 
+        options: AnyOptions, log: boolean = false) : Promise<IHeapSnapshot> {
+        if (log) Log.info(Loader.DOMAIN, Loader.TAG, `Loading heapsnapshot from file: ${file}`);         
+        const snapshot = await utils.getSnapshotFromFile(file, options);
+        if (log) Log.info(Loader.DOMAIN, Loader.TAG, `Loaded heapsnapshot from file: ${file}`);
+        return snapshot
+    }
+
+    /**
+     * Heapsnapshot 多文件加载
+     * @param files 多文件路径集合
+     * @returns IHeapSnapshot 对象集合
+     */
+    public static async loadFromFiles(files: Array<string>) : Promise<Array<IHeapSnapshot>> {
+        const result = new Array<IHeapSnapshot>();
+        files.forEach(async (file) => {
+            const heap = await getFullHeapFromFile(file);
+            result.push(heap);
+        });
+        return result;
+    }
+}

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

@@ -0,0 +1,252 @@
+/**
+ * Logger interface
+ */
+export interface ILogger {
+    /**
+     * print debug message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    debug(domain: string, tag: string, message: string) : void;
+
+    /**
+     * print info message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    info(domain: string, tag: string, message: string) : void;
+
+    /**
+     * print warn message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    warn(domain: string, tag: string, message: string) : void;
+
+    /**
+     * print error message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    error(domain: string, tag: string, message: string) : void;
+
+    /**
+     * print fatal message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    fatal(domain: string, tag: string, message: string) : void;
+}
+
+/**
+ * Log Type
+ */
+export enum LogType {
+    DEBUG = 'DEBUG',
+    INFO = 'INFO',
+    WARN = 'WARN',
+    ERROR = 'ERROR',
+    FATAL = 'FATAL'
+}
+
+/**
+ * Loggable interface
+ */
+export interface ILoggable {
+    /**
+     * Domain
+     */
+    DOMAIN: string;
+    /**
+     * Tag
+     */
+    TAG: string;
+}
+
+/**
+ * Logger class
+ */
+class Logger implements ILogger {
+    private _enableTime: boolean;
+
+    constructor(enableTime: boolean = true) {
+        this._enableTime = enableTime;
+    }
+
+    /**
+     * print log
+     * @param logType log type
+     * @param domain domain
+     * @param tag tag
+     * @param message message
+     */
+    private print(logType: LogType, domain: string, tag: string, message: string) {
+        const curTime = this._enableTime ? `${new Date().toISOString().replace('Z', '')}` : '*';
+        console.log(`${curTime} | [${logType}] | ${domain}-${tag}: ${message}`);
+    }
+
+    /**
+     * print debug message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    public debug(domain: string, tag: string, message: string) {
+        this.print(LogType.DEBUG, domain, tag, message)
+    }
+
+    /**
+     * print info message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    public info(domain: string, tag: string, message: string) {
+        this.print(LogType.INFO, domain, tag, message)
+    }
+
+    /**
+     * print warn message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    public warn(domain: string, tag: string, message: string) {
+        this.print(LogType.WARN, domain, tag, message)
+    }
+
+    /**
+     * print error message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    public error(domain: string, tag: string, message: string) {
+        this.print(LogType.ERROR, domain, tag, message)
+    }
+
+    /**
+     * print fatal message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    public fatal(domain: string, tag: string, message: string) {
+        this.print(LogType.FATAL, domain, tag, message)
+    }
+}
+
+/**
+ * Log class
+ */
+export class Log {
+    private static _logger: ILogger = new Logger(true);
+
+    /**
+     * set logger instance
+     * @param logger logger instance
+     */
+    public static setLogger(logger: ILogger) {
+        this._logger = logger;
+    }
+
+    /**
+     * print debug message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    public static debug(domain: string, tag: string, message: string) {
+        this._logger.debug(domain, tag, message);
+    }
+
+    /**
+     * print info message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    public static info(domain: string, tag: string, message: string) {
+        this._logger.info(domain, tag, message);
+    }
+
+    /**
+     * print warn message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    public static warn(domain: string, tag: string, message: string) {
+        this._logger.warn(domain, tag, message);
+    }
+
+    /**
+     * print error message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    public static error(domain: string, tag: string, message: string) {
+        this._logger.error(domain, tag, message);
+    }
+
+    /**
+     * print fatal message
+     * @param domain log domain
+     * @param tag log tag
+     * @param message log message
+     */
+    public static fatal(domain: string, tag: string, message: string) {
+        this._logger.fatal(domain, tag, message);
+    }
+
+    /**
+     * print debug message
+     * @param instance loggable instance
+     * @param message log message
+     */
+    public static debugX(instance: ILoggable, message: string) {
+        this._logger.debug(instance.DOMAIN, instance.TAG, message);
+    }
+
+    /**
+     * print info message
+     * @param instance loggable instance
+     * @param message log message
+     */
+    public static infoX(instance: ILoggable, message: string) {
+        this._logger.info(instance.DOMAIN, instance.TAG, message);
+    }
+
+    /**
+     * print warn message
+     * @param instance loggable instance
+     * @param message log message
+     */
+    public static warnX(instance: ILoggable, message: string) {
+        this._logger.warn(instance.DOMAIN, instance.TAG, message);
+    }
+
+    /**
+     * print error message
+     * @param instance loggable instance
+     * @param message log message
+     */
+    public static errorX(instance: ILoggable, message: string) {
+        this._logger.error(instance.DOMAIN, instance.TAG, message);
+    }
+
+    /**
+     * print fatal message
+     * @param instance loggable instance
+     * @param message log message
+     */
+    public static fatalX(instance: ILoggable, message: string) {
+        this._logger.fatal(instance.DOMAIN, instance.TAG, message);
+    }
+}