@memlab/core 1.0.8 → 1.0.9

package/dist/lib/leak-filters/rules/FilterOverSizedNodeAsLeak.rule.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterOverSizedNodeAsLeakRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+/**
+ * trivial nodes are not reported as memory leaks
+ */
+class FilterOverSizedNodeAsLeakRule {
+    filter(config, node) {
+        if (config.oversizeObjectAsLeak) {
+            return node.retainedSize > config.oversizeThreshold
+                ? BaseLeakFilter_rule_1.LeakDecision.LEAK
+                : BaseLeakFilter_rule_1.LeakDecision.NOT_LEAK;
+        }
+        return BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+}
+exports.FilterOverSizedNodeAsLeakRule = FilterOverSizedNodeAsLeakRule;

package/dist/lib/leak-filters/rules/FilterStackTraceFrame.rule.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { MemLabConfig } from '../../Config';
+import type { IHeapNode } from '../../Types';
+import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
+/**
+ * stack trace frames as memory leaks
+ */
+export declare class FilterStackTraceFrameRule implements ILeakObjectFilterRule {
+    filter(_config: MemLabConfig, node: IHeapNode): LeakDecision;
+}
+//# sourceMappingURL=FilterStackTraceFrame.rule.d.ts.map

package/dist/lib/leak-filters/rules/FilterStackTraceFrame.rule.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterStackTraceFrameRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+const Utils_1 = __importDefault(require("../../Utils"));
+/**
+ * stack trace frames as memory leaks
+ */
+class FilterStackTraceFrameRule {
+    filter(_config, node) {
+        return Utils_1.default.isStackTraceFrame(node)
+            ? BaseLeakFilter_rule_1.LeakDecision.LEAK
+            : BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+}
+exports.FilterStackTraceFrameRule = FilterStackTraceFrameRule;

package/dist/lib/leak-filters/rules/FilterTrivialNode.rule.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { MemLabConfig } from '../../Config';
+import type { IHeapNode } from '../../Types';
+import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
+/**
+ * trivial nodes are not reported as memory leaks
+ */
+export declare class FilterTrivialNodeRule implements ILeakObjectFilterRule {
+    filter(config: MemLabConfig, node: IHeapNode): LeakDecision;
+    protected isTrivialNode(node: IHeapNode): boolean;
+}
+//# sourceMappingURL=FilterTrivialNode.rule.d.ts.map

package/dist/lib/leak-filters/rules/FilterTrivialNode.rule.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterTrivialNodeRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+const Utils_1 = __importDefault(require("../../Utils"));
+/**
+ * trivial nodes are not reported as memory leaks
+ */
+class FilterTrivialNodeRule {
+    filter(config, node) {
+        return this.isTrivialNode(node)
+            ? BaseLeakFilter_rule_1.LeakDecision.NOT_LEAK
+            : BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+    isTrivialNode(node) {
+        return (node.type === 'number' ||
+            Utils_1.default.isStringNode(node) ||
+            node.type === 'hidden');
+    }
+}
+exports.FilterTrivialNodeRule = FilterTrivialNodeRule;

package/dist/lib/leak-filters/rules/FilterUnmountedFiberNode.rule.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { MemLabConfig } from '../../Config';
+import type { IHeapNode } from '../../Types';
+import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
+/**
+ * mark React FiberNodes without a React Fiber Root as memory leaks
+ */
+export declare class FilterUnmountedFiberNodeRule implements ILeakObjectFilterRule {
+    filter(config: MemLabConfig, node: IHeapNode): LeakDecision;
+    protected checkDetachedFiberNode(config: MemLabConfig, node: IHeapNode): boolean;
+}
+//# sourceMappingURL=FilterUnmountedFiberNode.rule.d.ts.map

package/dist/lib/leak-filters/rules/FilterUnmountedFiberNode.rule.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterUnmountedFiberNodeRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+const Utils_1 = __importDefault(require("../../Utils"));
+/**
+ * mark React FiberNodes without a React Fiber Root as memory leaks
+ */
+class FilterUnmountedFiberNodeRule {
+    filter(config, node) {
+        if (this.checkDetachedFiberNode(config, node)) {
+            return BaseLeakFilter_rule_1.LeakDecision.LEAK;
+        }
+        return BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+    checkDetachedFiberNode(config, node) {
+        if (!config.detectFiberNodeLeak ||
+            !Utils_1.default.isFiberNode(node) ||
+            Utils_1.default.hasHostRoot(node)) {
+            return false;
+        }
+        return !Utils_1.default.isNodeDominatedByDeletionsArray(node);
+    }
+}
+exports.FilterUnmountedFiberNodeRule = FilterUnmountedFiberNodeRule;

package/dist/trace-cluster/TraceBucket.d.ts

@@ -25,6 +25,7 @@ export default class NormalizedTrace {
     private static diffTraces;
     static diffClusters(newClusters: TraceCluster[], existingClusters: TraceCluster[]): TraceClusterDiff;
     static clusterLeakTraces(leakTraces: LeakTrace[]): Record<string, string>;
+    static filterClusters(clusters: TraceCluster[]): TraceCluster[];
     static clusterPaths(paths: LeakTracePathItem[], snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb, option?: {
         strategy?: IClusterStrategy;
     }): TraceCluster[];

package/dist/trace-cluster/TraceBucket.js

@@ -171,6 +171,16 @@ class NormalizedTrace {
         }, {});
         return labaledLeakTraces;
     }
+    static filterClusters(clusters) {
+        if (Config_1.default.clusterRetainedSizeThreshold <= 0) {
+            return clusters;
+        }
+        return clusters.filter(cluster => {
+            var _a;
+            return ((_a = cluster.retainedSize) !== null && _a !== void 0 ? _a : Infinity) >
+                Config_1.default.clusterRetainedSizeThreshold;
+        });
+    }
     static clusterPaths(paths, snapshot, aggregateDominatorMetrics, option = {}) {
         Console_1.default.overwrite('Clustering leak traces');
         if (paths.length === 0) {
@@ -192,7 +202,7 @@ class NormalizedTrace {
         // cluster traces
         const { allClusters } = NormalizedTrace.diffTraces(traces, [], option);
         // construct TraceCluster from clustering result
-        const clusters = allClusters.map((traces) => {
+        let clusters = allClusters.map((traces) => {
             const cluster = {
                 path: traceToPathMap.get(traces[0]),
                 count: traces.length,
@@ -205,6 +215,7 @@ class NormalizedTrace {
             this.calculateClusterRetainedSize(cluster, snapshot, aggregateDominatorMetrics);
             return cluster;
         });
+        clusters = NormalizedTrace.filterClusters(clusters);
         clusters.sort((c1, c2) => { var _a, _b; return ((_a = c2.retainedSize) !== null && _a !== void 0 ? _a : 0) - ((_b = c1.retainedSize) !== null && _b !== void 0 ? _b : 0); });
         Console_1.default.midLevel(`MemLab found ${clusters.length} leak(s)`);
         return clusters;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/core",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "license": "MIT",
   "description": "memlab core libraries",
   "author": "Liang Gong <lgong@fb.com>",
@@ -56,6 +56,7 @@
     "directory": "packages/core"
   },
   "scripts": {
+    "preinstall": "export PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true",
     "build-pkg": "tsc",
     "test-pkg": "jest .",
     "clean-pkg": "rm -rf ./dist && rm -rf ./node_modules && rm -f ./tsconfig.tsbuildinfo"