@memlab/core 1.0.0

package/dist/trace-cluster/TraceBucket.js

@@ -0,0 +1,238 @@
+"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 });
+const fs_1 = __importDefault(require("fs"));
+const Config_1 = __importDefault(require("../lib/Config"));
+const Console_1 = __importDefault(require("../lib/Console"));
+const Serializer_1 = __importDefault(require("../lib/Serializer"));
+const Utils_1 = __importDefault(require("../lib/Utils"));
+const TraceElement_1 = require("./TraceElement");
+const TraceSimilarityStrategy_1 = __importDefault(require("./strategies/TraceSimilarityStrategy"));
+const TraceAsClusterStrategy_1 = __importDefault(require("./strategies/TraceAsClusterStrategy"));
+// sync up with html/intern/js/webspeed/memlab/lib/LeakCluster.js
+class NormalizedTrace {
+    constructor(p = null, snapshot = null) {
+        if (!p) {
+            this.trace = [];
+            this.traceSummary = '';
+        }
+        else {
+            this.trace = NormalizedTrace.pathToTrace(p, {
+                untilFirstDetachedDOMElem: true,
+            });
+            this.traceSummary = snapshot
+                ? Serializer_1.default.summarizePath(p, new Set(), snapshot)
+                : '';
+        }
+    }
+    // convert path to leak trace
+    static pathToTrace(p, options = {}) {
+        const skipRest = !!options.untilFirstDetachedDOMElem;
+        const shouldSkip = (node) => {
+            // only consider the trace from GC root to the first detached element
+            // NOTE: do not use utils.isDetachedDOMNode, which relies on
+            //       the fact that p.node is a HeapNode
+            return (skipRest &&
+                node.name.startsWith('Detached ') &&
+                node.name !== 'Detached InternalNode');
+        };
+        const trace = [];
+        let curItem = p;
+        while (curItem) {
+            if (curItem.node) {
+                trace.push(new TraceElement_1.NodeRecord(curItem.node));
+                if (shouldSkip(curItem.node)) {
+                    break;
+                }
+            }
+            if (curItem.edge) {
+                trace.push(new TraceElement_1.EdgeRecord(curItem.edge));
+            }
+            curItem = curItem.next;
+        }
+        return trace;
+    }
+    // convert leak trace to path
+    static traceToPath(trace) {
+        if (!trace) {
+            return {};
+        }
+        let p = {};
+        for (let i = trace.length - 1; i >= 0; --i) {
+            const item = trace[i];
+            if (item.kind === 'edge') {
+                p.edge = item;
+            }
+            if (item.kind === 'node') {
+                p.node = item;
+                p = { next: p };
+            }
+        }
+        return p.next || {};
+    }
+    getTraceSummary() {
+        return this.traceSummary;
+    }
+    static addLeakedNodeToCluster(cluster, path) {
+        const leakedNode = Utils_1.default.getLeakedNode(path);
+        if (!cluster.leakedNodeIds) {
+            cluster.leakedNodeIds = new Set();
+        }
+        if (leakedNode) {
+            cluster.leakedNodeIds.add(leakedNode.id);
+        }
+    }
+    static calculateClusterRetainedSize(cluster, snapshot, aggregateDominatorMetrics) {
+        if (!cluster.leakedNodeIds) {
+            return 0;
+        }
+        return (cluster.retainedSize = aggregateDominatorMetrics(cluster.leakedNodeIds, snapshot, () => true, (node) => node.retainedSize));
+    }
+    static samplePaths(paths) {
+        const maxCount = 5000;
+        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)}`);
+        }
+        const ret = [];
+        for (const p of paths) {
+            if (Math.random() < sampleRatio) {
+                ret.push(p);
+            }
+        }
+        return ret;
+    }
+    static diffTraces(newTraces, existingTraces, // existing representative traces
+    option = {}) {
+        var _a, _b;
+        const strategy = (_b = (_a = option.strategy) !== null && _a !== void 0 ? _a : Config_1.default.clusterStrategy) !== null && _b !== void 0 ? _b : new TraceSimilarityStrategy_1.default();
+        return strategy.diffTraces(newTraces, existingTraces);
+    }
+    static diffClusters(newClusters, existingClusters) {
+        Console_1.default.overwrite('Diffing clusters');
+        // build trace to cluster map
+        const traceToClusterMap = new Map();
+        const newTraces = [];
+        const convertOption = { untilFirstDetachedDOMElem: true };
+        for (const cluster of newClusters) {
+            const trace = NormalizedTrace.pathToTrace(cluster.path, convertOption);
+            newTraces.push(trace);
+            traceToClusterMap.set(trace, cluster);
+        }
+        const existingTraces = [];
+        for (const cluster of existingClusters) {
+            const trace = NormalizedTrace.pathToTrace(cluster.path, convertOption);
+            existingTraces.push(trace);
+            traceToClusterMap.set(trace, cluster);
+        }
+        // differing representative traces in existing clusters vs new traces
+        // and calculate which representative traces are stale
+        // and which new traces should form new clusters
+        const traceDiff = NormalizedTrace.diffTraces(newTraces, existingTraces);
+        const { staleClusters, clustersToAdd, allClusters } = traceDiff;
+        // map trace to cluster
+        const traceToCluster = (trace) => {
+            if (!traceToClusterMap.has(trace)) {
+                throw Utils_1.default.haltOrThrow('trace to cluster mapping failed');
+            }
+            return traceToClusterMap.get(trace);
+        };
+        return {
+            staleClusters: staleClusters.map(traceToCluster),
+            clustersToAdd: clustersToAdd.map(traceToCluster),
+            allClusters: allClusters.map(cluster => cluster.map(traceToCluster)),
+        };
+    }
+    static clusterLeakTraces(leakTraces) {
+        const { allClusters } = NormalizedTrace.diffTraces(leakTraces, []);
+        const lastNodeFromTrace = (trace) => trace[trace.length - 1];
+        const labaledLeakTraces = allClusters.reduce((acc, bucket) => {
+            const lastNodeFromFirstTrace = lastNodeFromTrace(bucket[0]);
+            bucket.map(lastNodeFromTrace).forEach(lastNodeInTrace => {
+                if (lastNodeInTrace.id == null || lastNodeFromFirstTrace.id == null) {
+                    throw new Error('node id not found in last node of the leak trace');
+                }
+                acc[lastNodeInTrace.id] = String(lastNodeFromFirstTrace.id);
+            });
+            return acc;
+        }, {});
+        return labaledLeakTraces;
+    }
+    static clusterPaths(paths, snapshot, aggregateDominatorMetrics, option = {}) {
+        Console_1.default.overwrite('Clustering leak traces');
+        if (paths.length === 0) {
+            Console_1.default.midLevel('No leaks found');
+            return [];
+        }
+        // sample paths if there are too many
+        paths = this.samplePaths(paths);
+        // build trace to path map
+        const traceToPathMap = new Map();
+        const traces = [];
+        for (const p of paths) {
+            const trace = NormalizedTrace.pathToTrace(p, {
+                untilFirstDetachedDOMElem: true,
+            });
+            traceToPathMap.set(trace, p);
+            traces.push(trace);
+        }
+        // cluster traces
+        const { allClusters } = NormalizedTrace.diffTraces(traces, [], option);
+        // construct TraceCluster from clustering result
+        const clusters = allClusters.map((traces) => {
+            const cluster = {
+                path: traceToPathMap.get(traces[0]),
+                count: traces.length,
+                snapshot,
+                retainedSize: 0,
+            };
+            traces.forEach((trace) => {
+                NormalizedTrace.addLeakedNodeToCluster(cluster, traceToPathMap.get(trace));
+            });
+            this.calculateClusterRetainedSize(cluster, snapshot, aggregateDominatorMetrics);
+            return cluster;
+        });
+        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;
+    }
+    static generateUnClassifiedClusters(paths, snapshot, aggregateDominatorMetrics) {
+        return this.clusterPaths(paths, snapshot, aggregateDominatorMetrics, {
+            strategy: new TraceAsClusterStrategy_1.default(),
+        });
+    }
+    static loadCluster() {
+        let ret = [];
+        const file = Config_1.default.traceClusterFile;
+        if (!fs_1.default.existsSync(file)) {
+            return ret;
+        }
+        try {
+            const content = fs_1.default.readFileSync(file, 'UTF-8');
+            ret = JSON.parse(content);
+        }
+        catch (ex) {
+            throw Utils_1.default.haltOrThrow(Utils_1.default.getError(ex));
+        }
+        return ret;
+    }
+    static saveCluster(clusters) {
+        const file = Config_1.default.traceClusterFile;
+        const content = JSON.stringify(clusters, null, 2);
+        fs_1.default.writeFileSync(file, content, 'UTF-8');
+    }
+}
+exports.default = NormalizedTrace;

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

@@ -0,0 +1,71 @@
+/**
+ * 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 { EdgeIterationCallback, IHeapEdge, IHeapLocation, IHeapNode, IHeapSnapshot, IHeapStringNode, Nullable } from '../lib/Types';
+export declare class NodeRecord implements IHeapNode {
+    kind: string;
+    name: string;
+    type: string;
+    id: number;
+    is_detached: boolean;
+    detachState: number;
+    attributes: number;
+    self_size: number;
+    edge_count: number;
+    trace_node_id: number;
+    nodeIndex: number;
+    retainedSize: number;
+    highlight?: boolean;
+    markAsDetached(): void;
+    get isString(): boolean;
+    set isString(b: boolean);
+    set snapshot(s: IHeapSnapshot);
+    get snapshot(): IHeapSnapshot;
+    set references(r: IHeapEdge[]);
+    get references(): IHeapEdge[];
+    forEachReference(_callback: EdgeIterationCallback): void;
+    set referrers(r: IHeapEdge[]);
+    get referrers(): IHeapEdge[];
+    toStringNode(): IHeapStringNode;
+    forEachReferrer(_callback: EdgeIterationCallback): void;
+    findReference(): Nullable<IHeapEdge>;
+    findAnyReferrer(): Nullable<IHeapEdge>;
+    findReferrers(): IHeapEdge[];
+    set pathEdge(r: IHeapEdge);
+    get pathEdge(): IHeapEdge;
+    set dominatorNode(r: IHeapNode);
+    get dominatorNode(): IHeapNode;
+    set location(r: IHeapLocation);
+    get location(): IHeapLocation;
+    getReference(_edgeName: string | number, _edgeType?: string): Nullable<IHeapEdge>;
+    getReferenceNode(_edgeName: string | number, _edgeType?: string): Nullable<IHeapNode>;
+    getAnyReferrer(_edgeName: string | number, _edgeType?: string): Nullable<IHeapEdge>;
+    getAnyReferrerNode(_edgeName: string | number, _edgeType?: string): Nullable<IHeapNode>;
+    getReferrers(_edgeName: string | number, _edgeType?: string): IHeapEdge[];
+    getReferrerNodes(_edgeName: string | number, _edgeType?: string): IHeapNode[];
+    constructor(node: IHeapNode);
+    private extraceNodeName;
+}
+export declare class EdgeRecord implements IHeapEdge {
+    kind: string;
+    name_or_index: string | number;
+    type: string;
+    edgeIndex: number;
+    is_index: boolean;
+    to_node: number;
+    constructor(edge: IHeapEdge);
+    set snapshot(s: IHeapSnapshot);
+    get snapshot(): IHeapSnapshot;
+    set toNode(s: IHeapNode);
+    get toNode(): IHeapNode;
+    set fromNode(s: IHeapNode);
+    get fromNode(): IHeapNode;
+}
+export declare type NormalizedTraceElement = NodeRecord | EdgeRecord;
+//# sourceMappingURL=TraceElement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TraceElement.d.ts","sourceRoot":"","sources":["../../src/trace-cluster/TraceElement.ts"],"names":[],"mappings":"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"}

package/dist/trace-cluster/TraceElement.js

@@ -0,0 +1,182 @@
+"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.EdgeRecord = exports.NodeRecord = void 0;
+const Utils_1 = __importDefault(require("../lib/Utils"));
+class NodeRecord {
+    constructor(node) {
+        this.kind = 'node';
+        this.name = this.extraceNodeName(node);
+        this.type = node.type;
+        this.id = node.id;
+        this.is_detached = node.is_detached;
+        this.detachState = node.detachState;
+        this.attributes = node.attributes;
+        this.self_size = node.self_size;
+        this.edge_count = node.edge_count;
+        this.trace_node_id = node.trace_node_id;
+        this.nodeIndex = node.nodeIndex;
+        this.retainedSize = node.retainedSize;
+        this.highlight = node.highlight;
+    }
+    markAsDetached() {
+        throw new Error('NodeRecord.markAsDetached not callable.');
+    }
+    get isString() {
+        const type = this.type;
+        return (type === 'string' ||
+            type === 'sliced string' ||
+            type === 'concatenated string');
+    }
+    set isString(b) {
+        throw new Error('NodeRecord.string cannot be assigned');
+    }
+    set snapshot(s) {
+        throw new Error('NodeRecord.snapshot cannot be assigned.');
+    }
+    get snapshot() {
+        throw new Error('NodeRecord.snapshot cannot be read.');
+    }
+    set references(r) {
+        throw new Error('NodeRecord.references cannot be assigned');
+    }
+    get references() {
+        throw new Error('NodeRecord.references cannot be read');
+    }
+    forEachReference(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _callback) {
+        throw new Error('NodeRecord.forEachReference is not implemented');
+    }
+    set referrers(r) {
+        throw new Error('NodeRecord.referrers cannot be assigned');
+    }
+    get referrers() {
+        throw new Error('NodeRecord.referrers cannot be read');
+    }
+    toStringNode() {
+        throw new Error('NodeRecord.toStringNode is not implemented');
+    }
+    forEachReferrer(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _callback) {
+        throw new Error('NodeRecord.forEachReferrer is not implemented');
+    }
+    findReference() {
+        throw new Error('NodeRecord.findReference is not implemented');
+    }
+    findAnyReferrer() {
+        throw new Error('NodeRecord.findAnyReferrer is not implemented');
+    }
+    findReferrers() {
+        throw new Error('NodeRecord.findReferrers is not implemented');
+    }
+    set pathEdge(r) {
+        throw new Error('NodeRecord.pathEdge cannot be assigned');
+    }
+    get pathEdge() {
+        throw new Error('NodeRecord.pathEdge cannot be read');
+    }
+    set dominatorNode(r) {
+        throw new Error('NodeRecord.pathEdge cannot be assigned');
+    }
+    get dominatorNode() {
+        throw new Error('NodeRecord.pathEdge cannot be read');
+    }
+    set location(r) {
+        throw new Error('NodeRecord.location cannot be assigned');
+    }
+    get location() {
+        throw new Error('NodeRecord.location cannot be read');
+    }
+    getReference(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeName, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeType) {
+        throw new Error('NodeRecord.getReference is not implemented');
+    }
+    getReferenceNode(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeName, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeType) {
+        throw new Error('NodeRecord.getReferenceNode is not implemented');
+    }
+    getAnyReferrer(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeName, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeType) {
+        throw new Error('NodeRecord.getReferrer is not implemented');
+    }
+    getAnyReferrerNode(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeName, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeType) {
+        throw new Error('NodeRecord.getReferrerNode is not implemented');
+    }
+    getReferrers(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeName, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeType) {
+        throw new Error('NodeRecord.getReferrers is not implemented');
+    }
+    getReferrerNodes(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeName, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _edgeType) {
+        throw new Error('NodeRecord.getReferrerNodes is not implemented');
+    }
+    extraceNodeName(node) {
+        // deserialized node may not have snapshot info
+        if (!node.snapshot || !Utils_1.default.isFiberNode(node)) {
+            return node.name;
+        }
+        return Utils_1.default.extractFiberNodeInfo(node);
+    }
+}
+exports.NodeRecord = NodeRecord;
+class EdgeRecord {
+    constructor(edge) {
+        this.kind = 'edge';
+        this.name_or_index = edge.name_or_index;
+        this.type = edge.type;
+        this.edgeIndex = edge.edgeIndex;
+        this.is_index = edge.is_index;
+        this.to_node = edge.to_node;
+    }
+    set snapshot(s) {
+        throw new Error('EdgeRecord.snapshot cannot be assigned.');
+    }
+    get snapshot() {
+        throw new Error('EdgeRecord.snapshot cannot be read.');
+    }
+    set toNode(s) {
+        throw new Error('EdgeRecord.toNode cannot be assigned.');
+    }
+    get toNode() {
+        throw new Error('EdgeRecord.toNode cannot be read.');
+    }
+    set fromNode(s) {
+        throw new Error('EdgeRecord.fromNode cannot be assigned.');
+    }
+    get fromNode() {
+        throw new Error('EdgeRecord.fromNode cannot be read.');
+    }
+}
+exports.EdgeRecord = EdgeRecord;

package/dist/trace-cluster/strategies/TraceAsClusterStrategy.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 { IClusterStrategy, LeakTrace, TraceDiff } from '../../lib/Types';
+export default class TraceAsClusterStrategy implements IClusterStrategy {
+    diffTraces(newTraces: LeakTrace[], existingTraces: LeakTrace[]): TraceDiff;
+    static isSimilarTrace(t1: LeakTrace, t2: LeakTrace): boolean;
+}
+//# sourceMappingURL=TraceAsClusterStrategy.d.ts.map

package/dist/trace-cluster/strategies/TraceAsClusterStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TraceAsClusterStrategy.d.ts","sourceRoot":"","sources":["../../../src/trace-cluster/strategies/TraceAsClusterStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,gBAAgB,EAAE,SAAS,EAAE,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAI5E,MAAM,CAAC,OAAO,OAAO,sBAAuB,YAAW,gBAAgB;IAC9D,UAAU,CACf,SAAS,EAAE,SAAS,EAAE,EACtB,cAAc,EAAE,SAAS,EAAE,GAC1B,SAAS;IAkBZ,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO;CAG7D"}

package/dist/trace-cluster/strategies/TraceAsClusterStrategy.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 });
+const ClusterUtils_1 = __importDefault(require("../ClusterUtils"));
+// each trace is a cluster
+class TraceAsClusterStrategy {
+    diffTraces(newTraces, existingTraces) {
+        // duplicated cluster to remove
+        const staleClusters = [];
+        // new cluster to save
+        const clustersToAdd = [];
+        // all clusters, with duplicated cluters in the same sub-array
+        const clusters = existingTraces.map(trace => [trace]);
+        // checking new clusters
+        for (let i = 0; i < newTraces.length; ++i) {
+            const traceToCheck = newTraces[i];
+            clustersToAdd.push(traceToCheck);
+            clusters.push([traceToCheck]);
+        }
+        return { staleClusters, clustersToAdd, allClusters: clusters };
+    }
+    static isSimilarTrace(t1, t2) {
+        return ClusterUtils_1.default.isSimilarTrace(t1, t2);
+    }
+}
+exports.default = TraceAsClusterStrategy;

package/dist/trace-cluster/strategies/TraceSimilarityStrategy.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 { IClusterStrategy, LeakTrace, TraceDiff } from '../../lib/Types';
+export default class TraceSimilarityStrategy implements IClusterStrategy {
+    diffTraces(newTraces: LeakTrace[], existingTraces: LeakTrace[]): TraceDiff;
+    static isSimilarTrace(t1: LeakTrace, t2: LeakTrace): boolean;
+}
+//# sourceMappingURL=TraceSimilarityStrategy.d.ts.map

package/dist/trace-cluster/strategies/TraceSimilarityStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TraceSimilarityStrategy.d.ts","sourceRoot":"","sources":["../../../src/trace-cluster/strategies/TraceSimilarityStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,gBAAgB,EAAE,SAAS,EAAE,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAI5E,MAAM,CAAC,OAAO,OAAO,uBAAwB,YAAW,gBAAgB;IAC/D,UAAU,CACf,SAAS,EAAE,SAAS,EAAE,EACtB,cAAc,EAAE,SAAS,EAAE,GAC1B,SAAS;IA0CZ,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO;CAG7D"}

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

@@ -0,0 +1,60 @@
+"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 });
+const ClusterUtils_1 = __importDefault(require("../ClusterUtils"));
+// cluster by putting similar traces together
+class TraceSimilarityStrategy {
+    diffTraces(newTraces, existingTraces) {
+        // duplicated cluster to remove
+        const staleClusters = [];
+        // new cluster to save
+        const clustersToAdd = [];
+        // all clusters, with duplicated cluters in the same sub-array
+        const clusters = [];
+        // consolidating existing clusters
+        if (existingTraces.length > 0) {
+            clusters.push([existingTraces[0]]);
+            outer: for (let i = 1; i < existingTraces.length; ++i) {
+                const traceToCheck = existingTraces[i];
+                for (let j = 0; j < clusters.length; ++j) {
+                    const repTrace = clusters[j][0];
+                    if (TraceSimilarityStrategy.isSimilarTrace(repTrace, traceToCheck)) {
+                        staleClusters.push(traceToCheck);
+                        clusters[j].push(traceToCheck);
+                        continue outer;
+                    }
+                }
+                clusters.push([traceToCheck]);
+            }
+        }
+        // checking new clusters
+        outer: for (let i = 0; i < newTraces.length; ++i) {
+            const traceToCheck = newTraces[i];
+            for (let j = 0; j < clusters.length; ++j) {
+                const repTrace = clusters[j][0];
+                if (TraceSimilarityStrategy.isSimilarTrace(repTrace, traceToCheck)) {
+                    clusters[j].push(traceToCheck);
+                    continue outer;
+                }
+            }
+            clustersToAdd.push(traceToCheck);
+            clusters.push([traceToCheck]);
+        }
+        return { staleClusters, clustersToAdd, allClusters: clusters };
+    }
+    static isSimilarTrace(t1, t2) {
+        return ClusterUtils_1.default.isSimilarTrace(t1, t2);
+    }
+}
+exports.default = TraceSimilarityStrategy;