@memlab/core 1.1.19 → 1.1.21

package/dist/logger/LeakClusterLogger.js

@@ -187,6 +187,7 @@ class LeakClusterLogger {
             leak_trace_summary: trace.getTraceSummary(),
             interaction_vector: interactionVector,
             meta_data: JSON.stringify({
+                extraRunInfo: Utils_1.default.mapToObject(Config_1.default.extraRunInfoMap),
                 browser_info: BrowserInfo_1.default,
                 visit_plan: tabsOrder,
                 trace_record: TraceBucket_1.default.pathToTrace(cluster.path),

package/dist/paths/TraceFinder.js

@@ -428,9 +428,23 @@ class TraceFinder {
         return false;
     }
     isLessPreferableEdge(edge) {
+        const fromNode = edge.fromNode;
+        const toNode = edge.toNode;
         // pending activities -> DOM element is less preferrable
-        if (Utils_1.default.isPendingActivityNode(edge.fromNode) &&
-            Utils_1.default.isDOMNodeIncomplete(edge.toNode)) {
+        if (Utils_1.default.isPendingActivityNode(fromNode) &&
+            Utils_1.default.isDOMNodeIncomplete(toNode)) {
+            return true;
+        }
+        // detached DOM node -> non-detached DOM node is less preferable
+        if (Utils_1.default.isDetachedDOMNode(fromNode) &&
+            Utils_1.default.isDOMNodeIncomplete(toNode) &&
+            !Utils_1.default.isDetachedDOMNode(toNode)) {
+            return true;
+        }
+        // non-detached DOM node -> detached DOM node is less preferable
+        if (Utils_1.default.isDOMNodeIncomplete(fromNode) &&
+            !Utils_1.default.isDetachedDOMNode(fromNode) &&
+            Utils_1.default.isDetachedDOMNode(toNode)) {
             return true;
         }
         return Config_1.default.edgeNameGreyList.has(String(edge.name_or_index));

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

@@ -24,6 +24,7 @@ export default class NormalizedTrace {
     getTraceSummary(): string;
     static addLeakedNodeToCluster(cluster: TraceCluster, path: LeakTracePathItem): void;
     static calculateClusterRetainedSize(cluster: TraceCluster, snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb): number;
+    static getSamplePathMaxLength(paths: LeakTracePathItem[]): number;
     static samplePaths(paths: LeakTracePathItem[]): LeakTracePathItem[];
     private static diffTraces;
     static diffClusters(newClusters: TraceCluster[], existingClusters: TraceCluster[]): TraceClusterDiff;
@@ -36,7 +37,7 @@ export default class NormalizedTrace {
     private static buildTraceToPathMap;
     private static pushLeakPathToCluster;
     private static initEmptyCluster;
-    static clusterControlTreatmentPaths(controlPaths: LeakTracePathItem[], controlSnapshot: IHeapSnapshot, treatmentPaths: LeakTracePathItem[], treatmentSnapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb, option?: {
+    static clusterControlTreatmentPaths(leakPathsFromControlRuns: LeakTracePathItem[][], controlSnapshots: IHeapSnapshot[], treatmentPaths: LeakTracePathItem[], treatmentSnapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb, option?: {
         strategy?: IClusterStrategy;
     }): ControlTreatmentClusterResult;
     static generateUnClassifiedClusters(paths: LeakTracePathItem[], snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb): TraceCluster[];

package/dist/trace-cluster/TraceBucket.js

@@ -122,16 +122,30 @@ class NormalizedTrace {
         }
         return (cluster.retainedSize = aggregateDominatorMetrics(cluster.leakedNodeIds, snapshot, () => true, (node) => node.retainedSize));
     }
+    static getSamplePathMaxLength(paths) {
+        const lengthArr = paths.map(p => Utils_1.default.getLeakTracePathLength(p));
+        return Math.max(30, Utils_1.default.getNumberAtPercentile(lengthArr, 80));
+    }
     static samplePaths(paths) {
         const maxCount = 5000;
+        if (paths.length <= maxCount) {
+            return [...paths];
+        }
         const sampleRatio = Math.min(1, maxCount / paths.length);
         if (sampleRatio < 1) {
             Console_1.default.warning('Sampling trace due to a large number of traces:');
             Console_1.default.lowLevel(` Number of Traces: ${paths.length}`);
-            Console_1.default.lowLevel(` Sampling Ratio:   ${Utils_1.default.getReadablePercent(sampleRatio)}`);
+            Console_1.default.lowLevel(` Sampling Ratio: ${Utils_1.default.getReadablePercent(sampleRatio)}`);
         }
         const ret = [];
+        const samplePathMaxLength = NormalizedTrace.getSamplePathMaxLength(paths);
+        if (Config_1.default.verbose) {
+            Console_1.default.lowLevel(` Sample Trace's Max Length: ${samplePathMaxLength}`);
+        }
         for (const p of paths) {
+            if (Utils_1.default.getLeakTracePathLength(p) > samplePathMaxLength) {
+                continue;
+            }
             if (Math.random() < sampleRatio) {
                 ret.push(p);
             }
@@ -294,19 +308,21 @@ class NormalizedTrace {
             leakedNodeIds: new Set(),
         };
     }
-    static clusterControlTreatmentPaths(controlPaths, controlSnapshot, treatmentPaths, treatmentSnapshot, aggregateDominatorMetrics, option = {}) {
+    static clusterControlTreatmentPaths(leakPathsFromControlRuns, controlSnapshots, treatmentPaths, treatmentSnapshot, aggregateDominatorMetrics, option = {}) {
         const result = {
             controlOnlyClusters: [],
             treatmentOnlyClusters: [],
             hybridClusters: [],
         };
         Console_1.default.overwrite('Clustering leak traces');
-        if (controlPaths.length === 0 && treatmentPaths.length === 0) {
+        const totalControlPaths = leakPathsFromControlRuns.reduce((count, leakPaths) => count + leakPaths.length, 0);
+        if (totalControlPaths === 0 && treatmentPaths.length === 0) {
             Console_1.default.midLevel('No leaks found');
             return result;
         }
         // sample paths if there are too many
-        controlPaths = this.samplePaths(controlPaths);
+        const flattenedLeakPathsFromControlRuns = leakPathsFromControlRuns.reduce((arr, leakPaths) => [...arr, ...leakPaths], []);
+        const controlPaths = this.samplePaths(flattenedLeakPathsFromControlRuns);
         treatmentPaths = this.samplePaths(treatmentPaths);
         // build control trace to control path map
         const controlTraceToPathMap = NormalizedTrace.buildTraceToPathMap(controlPaths);
@@ -316,6 +332,8 @@ class NormalizedTrace {
         const treatmentTraces = Array.from(treatmentTraceToPathMap.keys());
         // cluster traces from both the control group and the treatment group
         const { allClusters } = NormalizedTrace.diffTraces([...controlTraces, ...treatmentTraces], [], option);
+        // pick one of the control heap snapshots
+        const controlSnapshot = controlSnapshots[0];
         // construct TraceCluster from clustering result
         allClusters.forEach((traces) => {
             var _a, _b;

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

@@ -7,7 +7,7 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { EdgeIterationCallback, IHeapEdge, IHeapLocation, IHeapNode, IHeapSnapshot, IHeapStringNode, Nullable } from '../lib/Types';
+import type { AnyValue, EdgeIterationCallback, IHeapEdge, IHeapLocation, IHeapNode, IHeapSnapshot, IHeapStringNode, Nullable } from '../lib/Types';
 export declare class NodeRecord implements IHeapNode {
     kind: string;
     name: string;
@@ -32,11 +32,14 @@ export declare class NodeRecord implements IHeapNode {
     forEachReference(_callback: EdgeIterationCallback): void;
     set referrers(r: IHeapEdge[]);
     get referrers(): IHeapEdge[];
+    get numOfReferrers(): number;
     toStringNode(): IHeapStringNode;
     forEachReferrer(_callback: EdgeIterationCallback): void;
     findAnyReference(): Nullable<IHeapEdge>;
     findAnyReferrer(): Nullable<IHeapEdge>;
+    findAnyReferrerNode(): Nullable<IHeapNode>;
     findReferrers(): IHeapEdge[];
+    findReferrerNodes(): IHeapNode[];
     set hasPathEdge(f: boolean);
     get hasPathEdge(): boolean;
     set pathEdge(r: IHeapEdge);
@@ -51,6 +54,7 @@ export declare class NodeRecord implements IHeapNode {
     getAnyReferrerNode(_edgeName: string | number, _edgeType?: string): Nullable<IHeapNode>;
     getReferrers(_edgeName: string | number, _edgeType?: string): IHeapEdge[];
     getReferrerNodes(_edgeName: string | number, _edgeType?: string): IHeapNode[];
+    toJSONString(...args: Array<AnyValue>): string;
     constructor(node: IHeapNode);
     private extraceNodeName;
 }
@@ -62,6 +66,7 @@ export declare class EdgeRecord implements IHeapEdge {
     is_index: boolean;
     to_node: number;
     constructor(edge: IHeapEdge);
+    toJSONString(...args: Array<AnyValue>): string;
     set snapshot(s: IHeapSnapshot);
     get snapshot(): IHeapSnapshot;
     set toNode(s: IHeapNode);

package/dist/trace-cluster/TraceElement.js

@@ -62,6 +62,9 @@ class NodeRecord {
     get referrers() {
         throw new Error('NodeRecord.referrers cannot be read');
     }
+    get numOfReferrers() {
+        throw new Error('NodeRecord.numOfReferrers cannot be read');
+    }
     toStringNode() {
         throw new Error('NodeRecord.toStringNode is not implemented');
     }
@@ -76,9 +79,15 @@ class NodeRecord {
     findAnyReferrer() {
         throw new Error('NodeRecord.findAnyReferrer is not implemented');
     }
+    findAnyReferrerNode() {
+        throw new Error('NodeRecord.findAnyReferrerNode is not implemented');
+    }
     findReferrers() {
         throw new Error('NodeRecord.findReferrers is not implemented');
     }
+    findReferrerNodes() {
+        throw new Error('NodeRecord.findReferrerNodes is not implemented');
+    }
     set hasPathEdge(f) {
         throw new Error('NodeRecord.hasPathEdge cannot be assigned');
     }
@@ -145,6 +154,20 @@ class NodeRecord {
     _edgeType) {
         throw new Error('NodeRecord.getReferrerNodes is not implemented');
     }
+    toJSONString(...args) {
+        const rep = {
+            id: this.id,
+            kind: this.kind,
+            name: this.name,
+            type: this.type,
+            self_size: this.self_size,
+            trace_node_id: this.trace_node_id,
+            nodeIndex: this.nodeIndex,
+            incomingEdgeCount: this.numOfReferrers,
+            contructorName: this.constructor.name,
+        };
+        return JSON.stringify(rep, ...args);
+    }
     extraceNodeName(node) {
         // deserialized node may not have snapshot info
         if (!node.snapshot || !Utils_1.default.isFiberNode(node)) {
@@ -163,6 +186,16 @@ class EdgeRecord {
         this.is_index = edge.is_index;
         this.to_node = edge.to_node;
     }
+    toJSONString(...args) {
+        const rep = {
+            kind: this.kind,
+            name_or_index: this.name_or_index,
+            type: this.type,
+            edgeIndex: this.edgeIndex,
+            to_node: this.to_node,
+        };
+        return JSON.stringify(rep, ...args);
+    }
     set snapshot(s) {
         throw new Error('EdgeRecord.snapshot cannot be assigned.');
     }

package/dist/trace-cluster/strategies/TraceSimilarityStrategy.js

@@ -12,6 +12,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const Config_1 = __importDefault(require("../../lib/Config"));
+const Console_1 = __importDefault(require("../../lib/Console"));
 const ClusterUtils_1 = __importDefault(require("../ClusterUtils"));
 // cluster by putting similar traces together
 class TraceSimilarityStrategy {
@@ -41,6 +43,13 @@ class TraceSimilarityStrategy {
         // checking new clusters
         outer: for (let i = 0; i < newTraces.length; ++i) {
             const traceToCheck = newTraces[i];
+            // use an odd number as the divider. If we choose 10 as the divider,
+            // when updating the progress indicator, the final digit always ends
+            // with a zero, which can appear strange and not representative of
+            // the actual progress.
+            if (!Config_1.default.isContinuousTest && i % 17 === 0) {
+                Console_1.default.overwrite(`clustering trace: ${i} / ${newTraces.length}`);
+            }
             for (let j = 0; j < clusters.length; ++j) {
                 const repTrace = clusters[j][0];
                 if (TraceSimilarityStrategy.isSimilarTrace(repTrace, traceToCheck)) {
@@ -51,6 +60,7 @@ class TraceSimilarityStrategy {
             clustersToAdd.push(traceToCheck);
             clusters.push([traceToCheck]);
         }
+        Console_1.default.overwrite('');
         return { staleClusters, clustersToAdd, allClusters: clusters };
     }
     static isSimilarTrace(t1, t2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/core",
-  "version": "1.1.19",
+  "version": "1.1.21",
   "license": "MIT",
   "description": "memlab core libraries",
   "author": "Liang Gong <lgong@fb.com>",

package/static/visit-order-single-snapshot.json

@@ -0,0 +1,19 @@
+[
+  {
+    "name": "target",
+    "url": "",
+    "snapshot": true,
+    "screenshot": false,
+    "type": "target",
+    "idx": 1
+  },
+  {
+    "name": "final",
+    "url": "",
+    "delay": 10000,
+    "snapshot": true,
+    "screenshot": false,
+    "type": "final",
+    "idx": 2
+  }
+]