@memlab/core 1.0.0

package/dist/trace-cluster/ClusterUtilsHelper.js

@@ -0,0 +1,373 @@
+"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.debugTraceElementSimilarityStats = exports.debugLog = void 0;
+function NON_NULLABLE(v) {
+    if (v == null) {
+        throw new Error('value must not be null or undefined');
+    }
+    return v;
+}
+// Set this flag to true when debugging the leak trace clustering algorithm
+// to get more runtime information in terminal.
+const DEBUG = false;
+function debugLog(...args) {
+    if (!DEBUG) {
+        return;
+    }
+    if (typeof console === 'undefined' || typeof console.log !== 'function') {
+        return;
+    }
+    console.log(args.join(' |\t'));
+}
+exports.debugLog = debugLog;
+const debugTraceElementSimilarityStats = ({ elementA, elementB, matchedSum, totalSum, }) => {
+    const similarityScoreString = `${matchedSum} / ${totalSum}`;
+    if (elementA.kind === 'edge') {
+        debugLog(elementA.kind, elementA.name_or_index, elementB.name_or_index, similarityScoreString);
+        return;
+    }
+    debugLog(elementA.kind, elementA.name, elementB.name, similarityScoreString);
+};
+exports.debugTraceElementSimilarityStats = debugTraceElementSimilarityStats;
+const SIMILAR_TRACE_THRESHOLD = 0.8;
+const REACT_FIBER_EDGE_PREFIX = '__reactFiber$';
+const WINDOW_NODE_PREFIX = 'Window / ';
+const initialize = (heuristics) => {
+    const { edgeNameStopWords, nodeNameStopWords, similarWordRegExps, decendentDecayFactors, startingModuleForTraceMatching, } = heuristics;
+    function _searchForEdge(t, name) {
+        for (let i = 0; i < t.length; ++i) {
+            const traceElement = t[i];
+            if (traceElement.kind === 'edge' && 'name_or_index' in traceElement) {
+                if (name instanceof RegExp) {
+                    if (name.test(`${traceElement.name_or_index}`)) {
+                        return i;
+                    }
+                }
+                else if (traceElement.name_or_index === name) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+    function _searchForNode(t, name) {
+        for (let i = 0; i < t.length; ++i) {
+            const traceElement = t[i];
+            if (traceElement.kind === 'node' && 'name' in traceElement) {
+                if (name instanceof RegExp) {
+                    if (name.test(NON_NULLABLE(traceElement.name))) {
+                        return i;
+                    }
+                }
+                else if (traceElement.name === name) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+    function _searchForMatch(t1, t2, name) {
+        let i1 = _searchForEdge(t1, name);
+        let i2 = _searchForEdge(t2, name);
+        if (i1 >= 0 && i2 >= 0) {
+            return [i1, i2];
+        }
+        i1 = _searchForNode(t1, name);
+        i2 = _searchForNode(t2, name);
+        if (i1 >= 0 && i2 >= 0) {
+            return [i1, i2];
+        }
+        return null;
+    }
+    // the trace similarity calculation starts from modulesMap if
+    // both traces have the modulesMap heap object
+    function matchTraceStartItem(t1, t2) {
+        for (const name of startingModuleForTraceMatching) {
+            const ret = _searchForMatch(t1, t2, name);
+            if (ret) {
+                return ret;
+            }
+        }
+        return [0, 0];
+    }
+    function getNodeStopWordWeight(name) {
+        return _getStopWordWeight(nodeNameStopWords, name);
+    }
+    function getEdgeStopWordWeight(name) {
+        return _getStopWordWeight(edgeNameStopWords, name);
+    }
+    function _getStopWordWeight(stopWordsMap, name) {
+        if (stopWordsMap.has(name)) {
+            return NON_NULLABLE(stopWordsMap.get(name));
+        }
+        for (const stopWord of stopWordsMap.keys()) {
+            if (!(stopWord instanceof RegExp)) {
+                continue;
+            }
+            if (stopWord.test(`${name}`)) {
+                return NON_NULLABLE(stopWordsMap.get(stopWord));
+            }
+        }
+        return 1;
+    }
+    function getSimilarWordsWeight(name1, name2) {
+        const n1 = `${name1}`;
+        const n2 = `${name2}`;
+        for (const regexp of similarWordRegExps.keys()) {
+            if (regexp.test(n1) && regexp.test(n2)) {
+                return NON_NULLABLE(similarWordRegExps.get(regexp));
+            }
+        }
+        return 1;
+    }
+    function getDecendentDecayFactor(elem, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _elem2) {
+        for (const factors of decendentDecayFactors) {
+            if (factors.kind === elem.kind) {
+                if ('name' in elem && factors.name === elem.name) {
+                    return factors.decay;
+                }
+                if ('name_or_index' in elem && factors.name === elem.name_or_index) {
+                    return factors.decay;
+                }
+            }
+        }
+        return 1;
+    }
+    function isNodeNameSame(name1, name2) {
+        const isWindowNode1 = typeof name1 === 'string' && name1.startsWith(WINDOW_NODE_PREFIX);
+        const isWindowNode2 = typeof name2 === 'string' && name2.startsWith(WINDOW_NODE_PREFIX);
+        if (isWindowNode1 && isWindowNode2) {
+            return true;
+        }
+        return name1 === name2;
+    }
+    function isNameSimilar(name1, name2) {
+        const n1 = `${name1}`;
+        const n2 = `${name2}`;
+        for (const regexp of similarWordRegExps.keys()) {
+            if (regexp.test(n1) && regexp.test(n2)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function isEdgeNameSame(name1, name2) {
+        const isFiberEdge1 = typeof name1 === 'string' && name1.startsWith(REACT_FIBER_EDGE_PREFIX);
+        const isFiberEdge2 = typeof name2 === 'string' && name2.startsWith(REACT_FIBER_EDGE_PREFIX);
+        if (isFiberEdge1 && isFiberEdge2) {
+            return true;
+        }
+        return name1 === name2;
+    }
+    function representsNumber(value) {
+        if (typeof value === 'number') {
+            return true;
+        }
+        if (parseInt(value, 10) + '' === value + '') {
+            return true;
+        }
+        if (parseFloat(value) + '' === value + '') {
+            return true;
+        }
+        return false;
+    }
+    function areBothNodes(elem1, elem2) {
+        if (elem1 == null || elem2 == null) {
+            return false;
+        }
+        if (elem1.kind !== 'node' || elem2.kind !== 'node') {
+            return false;
+        }
+        if (elem1.type !== elem2.type) {
+            return false;
+        }
+        return true;
+    }
+    function isSameNode(elem1, elem2) {
+        if (!areBothNodes(elem1, elem2)) {
+            return false;
+        }
+        return isNodeNameSame(NON_NULLABLE(elem1.name), NON_NULLABLE(elem2.name));
+    }
+    function isSimilarNode(elem1, elem2) {
+        if (!areBothNodes(elem1, elem2)) {
+            return false;
+        }
+        return isNameSimilar(NON_NULLABLE(elem1.name), NON_NULLABLE(elem2.name));
+    }
+    function isSameEdge(trace1, i1, trace2, i2) {
+        const elem1 = trace1[i1];
+        const elem2 = trace2[i2];
+        if (elem1 == null || elem2 == null) {
+            return false;
+        }
+        if (elem1.kind !== 'edge' || elem2.kind !== 'edge') {
+            return false;
+        }
+        if (elem1.type !== elem2.type) {
+            return false;
+        }
+        // index properties are considered the same if
+        // their referrer node are the same
+        if (representsNumber(elem1.name_or_index) &&
+            representsNumber(elem2.name_or_index)) {
+            const referrer1 = trace1[i1 - 1];
+            const referrer2 = trace2[i2 - 1];
+            return isSameNode(referrer1, referrer2);
+        }
+        return isEdgeNameSame(NON_NULLABLE(elem1.name_or_index), NON_NULLABLE(elem2.name_or_index));
+    }
+    function areBothEdges(elem1, elem2) {
+        if (elem1 == null || elem2 == null) {
+            return false;
+        }
+        if (elem1.kind !== 'edge' || elem2.kind !== 'edge') {
+            return false;
+        }
+        if (elem1.type !== elem2.type) {
+            return false;
+        }
+        return true;
+    }
+    function isSimilarEdge(trace1, i1, trace2, i2) {
+        const elem1 = trace1[i1];
+        const elem2 = trace2[i2];
+        if (!areBothEdges(elem1, elem2)) {
+            return false;
+        }
+        // index properties are considered the same if
+        // their referrer node are the same
+        if (representsNumber(elem1.name_or_index) &&
+            representsNumber(elem2.name_or_index)) {
+            const referrer1 = trace1[i1 - 1];
+            const referrer2 = trace2[i2 - 1];
+            return (isSameNode(referrer1, referrer2) || isSimilarNode(referrer1, referrer2));
+        }
+        return isNameSimilar(NON_NULLABLE(elem1.name_or_index), NON_NULLABLE(elem2.name_or_index));
+    }
+    function isSameOrSimilarElement(trace1, i1, trace2, i2) {
+        const elem1 = trace1[i1];
+        const elem2 = trace2[i2];
+        if (!elem1 || !elem2) {
+            return false;
+        }
+        if (elem1.kind !== elem2.kind) {
+            return false;
+        }
+        if (elem1.kind === 'edge') {
+            if (isSameEdge(trace1, i1, trace2, i2)) {
+                return true;
+            }
+            return isSimilarEdge(trace1, i1, trace2, i2);
+        }
+        if (isSameNode(elem1, elem2)) {
+            return true;
+        }
+        return isSimilarNode(elem1, elem2);
+    }
+    function getDecayFactor(trace1, i1, trace2, i2) {
+        const elem1 = trace1[i1];
+        const elem2 = trace2[i2];
+        if (!elem1 || !elem2) {
+            return 1;
+        }
+        if (elem1.kind !== elem2.kind) {
+            return 1;
+        }
+        return getDecendentDecayFactor(elem1, elem2);
+    }
+    function getElementPairWeight(trace1, i1, trace2, i2) {
+        const elem1 = trace1[i1];
+        const elem2 = trace2[i2];
+        if (!elem1 || !elem2) {
+            return 1;
+        }
+        if (elem1.kind !== elem2.kind) {
+            return 1;
+        }
+        if (elem1.kind === 'edge') {
+            if (!isSameEdge(trace1, i1, trace2, i2)) {
+                return getSimilarWordsWeight(NON_NULLABLE(elem1.name_or_index), NON_NULLABLE(elem2.name_or_index));
+            }
+            const edgeName = NON_NULLABLE(elem1.name_or_index);
+            return getEdgeStopWordWeight(edgeName);
+        }
+        if (!isSameNode(elem1, elem2)) {
+            return getSimilarWordsWeight(NON_NULLABLE(elem1.name), NON_NULLABLE(elem2.name));
+        }
+        const nodeName = NON_NULLABLE(elem1.name);
+        return getNodeStopWordWeight(nodeName);
+    }
+    function getSimilarityByTraceElementList(t1, t2) {
+        // find first starting item that matches
+        let [i1, i2] = matchTraceStartItem(t1, t2);
+        const l1 = t1.length;
+        const l2 = t2.length;
+        const d1 = l1 - i1;
+        const d2 = l2 - i2;
+        let delta1 = 0.9 / d1;
+        let delta2 = 0.9 / d2;
+        let w1 = 1;
+        let w2 = 1;
+        const l = Math.max(l1, l2);
+        let matchedSum = 0;
+        let totalSum = 0;
+        while (i1 < l || i2 < l) {
+            const trace1 = t1;
+            const trace2 = t2;
+            const pw = getElementPairWeight(trace1, i1, trace2, i2);
+            if (isSameOrSimilarElement(trace1, i1, trace2, i2)) {
+                (0, exports.debugTraceElementSimilarityStats)({
+                    elementA: trace1[i1],
+                    elementB: trace2[i2],
+                    matchedSum,
+                    totalSum,
+                });
+                matchedSum += (w1 + w2) * pw;
+            }
+            totalSum += (w1 + w2) * pw;
+            const decayFactor = 0.99 * getDecayFactor(trace1, i1, trace2, i2);
+            w1 *= decayFactor;
+            w2 *= decayFactor;
+            delta1 *= decayFactor;
+            delta2 *= decayFactor;
+            if (w1 - delta1 >= 0) {
+                w1 -= delta1;
+            }
+            if (w2 - delta2 >= 0) {
+                w2 -= delta2;
+            }
+            ++i1;
+            ++i2;
+            if (i1 >= l1 || i2 >= l2) {
+                const sim = matchedSum / (totalSum + 0.0001);
+                if (sim > 0.9) {
+                    return sim;
+                }
+            }
+        }
+        return matchedSum / (totalSum + 0.0001);
+    }
+    function isSimilarTrace(t1, t2) {
+        const similarity = getSimilarityByTraceElementList(t1, t2);
+        debugLog(similarity);
+        return similarity >= SIMILAR_TRACE_THRESHOLD;
+    }
+    return {
+        isSimilarTrace,
+    };
+};
+exports.default = {
+    initialize,
+};

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

@@ -0,0 +1,22 @@
+/**
+ * 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
+ */
+declare const _default: {
+    edgeNameStopWords: Map<any, any>;
+    nodeNameStopWords: Map<any, any>;
+    similarWordRegExps: Map<any, any>;
+    decendentDecayFactors: {
+        kind: string;
+        name: string;
+        decay: number;
+    }[];
+    startingModuleForTraceMatching: (string | RegExp)[];
+};
+export default _default;
+//# sourceMappingURL=ClusteringHeuristics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ClusteringHeuristics.d.ts","sourceRoot":"","sources":["../../src/trace-cluster/ClusteringHeuristics.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;;;;;;cAUqC,MAAM;cAAQ,MAAM;eAAS,MAAM;;;;AAL3E,wBAUE"}

package/dist/trace-cluster/ClusteringHeuristics.js

@@ -0,0 +1,23 @@
+"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 InternalValueSetter_1 = require("../lib/InternalValueSetter");
+const Constant_1 = __importDefault(require("../lib/Constant"));
+exports.default = (0, InternalValueSetter_1.setInternalValue)({
+    edgeNameStopWords: new Map(),
+    nodeNameStopWords: new Map(),
+    similarWordRegExps: new Map(),
+    decendentDecayFactors: [],
+    startingModuleForTraceMatching: [],
+}, __filename, Constant_1.default.internalDir);

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

@@ -0,0 +1,22 @@
+/**
+ * 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
+ */
+declare type ClusteredLeakTraces = Record<string, string>;
+declare const _default: {
+    evaluateAdjustRandScore: (trueTraceIdLabelMap: ClusteredLeakTraces, predictedTraceIdLabelMap: ClusteredLeakTraces) => number;
+    vMeasure: (trueLabels: number[], predictedLabels: number[], beta?: number) => number;
+    completeness: (trueLabels: number[], predictedLabels: number[]) => number;
+    homogeneity: (trueLabels?: number[], predictedLabels?: number[]) => number;
+    getRepresentativeTraceMetrics: (trueTraceIdLabelMap: ClusteredLeakTraces, predictedTraceIdLabelMap: ClusteredLeakTraces) => {
+        omitted: number;
+        duplicated: number;
+    };
+};
+export default _default;
+//# sourceMappingURL=EvalutationMetric.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EvalutationMetric.d.ts","sourceRoot":"","sources":["../../src/trace-cluster/EvalutationMetric.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAqHH,aAAK,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;;;;;;;;;;;AA+ElD,wBAME"}

package/dist/trace-cluster/EvalutationMetric.js

@@ -0,0 +1,158 @@
+"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 });
+////////////////////////
+const zip = (arr1, arr2) => arr1.reduce((ret, el, idx) => {
+    ret.push([el, arr2[idx]]);
+    return ret;
+}, []);
+/*
+  countUnique returns array of count of unique items for given array of numbers.
+  For example, countUnique([1, 2, 3, 3, 2]) returns [['1', '2', '3'], [1, 2, 2]].
+    countUnique([[1, 2], [2, 3], [2, 3]]) returns [['1,2', '2,3'], [1, 2]].
+*/
+const countUnique = (arr = []) => {
+    const key = (el) => {
+        if (Array.isArray(el)) {
+            return el.join(',');
+        }
+        return `${el}`;
+    };
+    const map = new Map();
+    arr.forEach(el => {
+        const k = key(el);
+        if (map.has(key(el))) {
+            map.set(k, map.get(k) + 1);
+        }
+        else {
+            map.set(k, 1);
+        }
+    });
+    return [Array.from(map.keys()), Array.from(map.values())];
+};
+const entropy = (labels = []) => {
+    const nLabels = labels.length;
+    if (nLabels <= 1)
+        return 0;
+    const [, counts] = countUnique(labels);
+    const probabilities = counts.map(c => c / nLabels);
+    const nClassess = probabilities.filter(el => el !== 0).length;
+    if (nClassess <= 1)
+        return 0;
+    let ent = 0.0;
+    for (const prob of probabilities) {
+        ent -= prob * Math.log(prob);
+    }
+    return ent;
+};
+const homogeneity = (trueLabels = [], predictedLabels = []) => {
+    const trueLabelEntropy = entropy(trueLabels);
+    if (trueLabelEntropy == 0)
+        return 1;
+    // Combine two lists into a list of tuples which will be used for conditional Entropy.
+    const joined = zip(trueLabels, predictedLabels);
+    const joinedEntropy = entropy(joined);
+    const predictedLabelEntropy = entropy(predictedLabels);
+    // Conditional Entropy (Chain rule) - https://en.wikipedia.org/wiki/Conditional_entropy
+    // H(X|Y) = H(X,Y) - H(X)
+    const conditionalEntropy = joinedEntropy - predictedLabelEntropy;
+    const h = 1 - conditionalEntropy / trueLabelEntropy;
+    return h;
+};
+const completeness = (trueLabels, predictedLabels) => {
+    const predictedLabelEntropy = entropy(predictedLabels);
+    if (predictedLabelEntropy == 0)
+        return 1;
+    // # Combine two lists into a list of tuples.
+    // # For example, classes [1, 3] and clusters [20, 30] become [(1, 20), (3, 30)].
+    const joined = zip(trueLabels, predictedLabels);
+    const joinedEntropy = entropy(joined);
+    const trueLabelEntropy = entropy(trueLabels);
+    const conditionalEntropy = joinedEntropy - trueLabelEntropy;
+    const c = 1 - conditionalEntropy / predictedLabelEntropy;
+    return c;
+};
+/*
+  Ratio of weight attributed to homogeneity vs completeness.
+  If beta is greater than 1, completeness is weighted more strongly in the calculation.
+  If beta is less than 1, homogeneity is weighted more strongly.
+*/
+const vMeasure = (trueLabels, predictedLabels, beta = 1) => {
+    const h = homogeneity(trueLabels, predictedLabels);
+    const c = completeness(trueLabels, predictedLabels);
+    const v = ((1 + beta) * h * c) / (beta * h + c);
+    return v;
+};
+/**
+ * The dataset the function takes as argument is map of key:value pairs.
+ *  Key is trace_id and value is the cluster_id, which is another trace_id
+ *  that represents the cluster it, belongs to
+ * @param trueTraceIdLabelMap Baseline
+ * @param predictedTraceIdLabelMap Predicted outcome from some clustering
+ * @returns numeric evaluation ([-1:1] 1 being identical) of how close the traces are clustered using Adjust Rand Index formula.
+ */
+const evaluateAdjustRandScore = (trueTraceIdLabelMap, predictedTraceIdLabelMap) => {
+    let truePositive = 0;
+    let falsePositive = 0;
+    let falseNegative = 0;
+    let trueNegative = 0;
+    const predictedTraceIDs = Object.keys(predictedTraceIdLabelMap);
+    for (let i = 0; i < predictedTraceIDs.length - 1; i++) {
+        for (let j = i + 1; j < predictedTraceIDs.length - 1; j++) {
+            const [traceIdA, traceIdB] = [predictedTraceIDs[i], predictedTraceIDs[j]];
+            const isSameInPredicted = predictedTraceIdLabelMap[traceIdA] ===
+                predictedTraceIdLabelMap[traceIdB];
+            const isSameInTrue = trueTraceIdLabelMap[traceIdA] === trueTraceIdLabelMap[traceIdB];
+            if (isSameInPredicted && isSameInTrue) {
+                truePositive++;
+            }
+            else if (!isSameInPredicted && isSameInTrue) {
+                falseNegative++;
+            }
+            else if (isSameInPredicted && !isSameInTrue) {
+                falsePositive++;
+            }
+            else {
+                trueNegative++;
+            }
+        }
+    }
+    const n = predictedTraceIDs.length;
+    // Total number of pairs
+    const totalNumberOfPairs = (n * (n - 1)) / 2;
+    // The formula is from https://arxiv.org/pdf/2002.03677.pdf
+    const ARI = (totalNumberOfPairs * (truePositive + trueNegative) -
+        ((truePositive + falsePositive) * (truePositive + falseNegative) +
+            (falseNegative + trueNegative) * (falsePositive + trueNegative))) /
+        (Math.pow(totalNumberOfPairs, 2) -
+            ((truePositive + falsePositive) * (truePositive + falseNegative) +
+                (falseNegative + trueNegative) * (falsePositive + trueNegative)));
+    return ARI;
+};
+const getRepresentativeTraceMetrics = (trueTraceIdLabelMap, predictedTraceIdLabelMap) => {
+    const [uniqTrueLabels] = countUnique(Object.values(trueTraceIdLabelMap));
+    const nTrueLabels = uniqTrueLabels.length;
+    const [uniqPredLabels] = countUnique(Object.values(predictedTraceIdLabelMap));
+    const predLabelToTrueLabel = uniqPredLabels.map(representativeTraceId => trueTraceIdLabelMap[representativeTraceId]);
+    const [, countsOfTrueLabelsForPredicted] = countUnique(predLabelToTrueLabel);
+    const nClustersThatShouldMerge = countsOfTrueLabelsForPredicted.filter(count => count > 1).length;
+    return {
+        omitted: (nTrueLabels - countsOfTrueLabelsForPredicted.length) / nTrueLabels,
+        duplicated: nClustersThatShouldMerge / nTrueLabels,
+    };
+};
+exports.default = {
+    evaluateAdjustRandScore,
+    vMeasure,
+    completeness,
+    homogeneity,
+    getRepresentativeTraceMetrics,
+};

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

@@ -0,0 +1,36 @@
+/**
+ * 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 { IHeapNode, IHeapSnapshot, LeakTrace, LeakTracePathItem, Optional, TraceCluster, TraceClusterDiff, IClusterStrategy } from '../lib/Types';
+import type { NormalizedTraceElement } from './TraceElement';
+declare type AggregateNodeCb = (ids: Set<number>, snapshot: IHeapSnapshot, checkCb: (node: IHeapNode) => boolean, calculateCb: (node: IHeapNode) => number) => number;
+export default class NormalizedTrace {
+    private trace;
+    private traceSummary;
+    constructor(p?: LeakTracePathItem | null, snapshot?: IHeapSnapshot | null);
+    static pathToTrace(p: LeakTracePathItem, options?: {
+        untilFirstDetachedDOMElem?: boolean;
+    }): NormalizedTraceElement[];
+    static traceToPath(trace: Optional<LeakTrace>): LeakTracePathItem;
+    getTraceSummary(): string;
+    static addLeakedNodeToCluster(cluster: TraceCluster, path: LeakTracePathItem): void;
+    static calculateClusterRetainedSize(cluster: TraceCluster, snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb): number;
+    static samplePaths(paths: LeakTracePathItem[]): LeakTracePathItem[];
+    private static diffTraces;
+    static diffClusters(newClusters: TraceCluster[], existingClusters: TraceCluster[]): TraceClusterDiff;
+    static clusterLeakTraces(leakTraces: LeakTrace[]): Record<string, string>;
+    static clusterPaths(paths: LeakTracePathItem[], snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb, option?: {
+        strategy?: IClusterStrategy;
+    }): TraceCluster[];
+    static generateUnClassifiedClusters(paths: LeakTracePathItem[], snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb): TraceCluster[];
+    static loadCluster(): NormalizedTrace[];
+    static saveCluster(clusters: NormalizedTrace[]): void;
+}
+export {};
+//# sourceMappingURL=TraceBucket.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TraceBucket.d.ts","sourceRoot":"","sources":["../../src/trace-cluster/TraceBucket.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,iBAAiB,EAEjB,QAAQ,EACR,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,gBAAgB,CAAC;AAW3D,aAAK,eAAe,GAAG,CACrB,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,EAChB,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,OAAO,EACrC,WAAW,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,MAAM,KACrC,MAAM,CAAC;AAIZ,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,YAAY,CAAS;gBAE3B,CAAC,GAAE,iBAAiB,GAAG,IAAW,EAClC,QAAQ,GAAE,aAAa,GAAG,IAAW;IAgBvC,MAAM,CAAC,WAAW,CAChB,CAAC,EAAE,iBAAiB,EACpB,OAAO,GAAE;QACP,yBAAyB,CAAC,EAAE,OAAO,CAAC;KAChC,GACL,sBAAsB,EAAE;IA8B3B,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,iBAAiB;IAkBjE,eAAe,IAAI,MAAM;IAIzB,MAAM,CAAC,sBAAsB,CAC3B,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,iBAAiB,GACtB,IAAI;IAUP,MAAM,CAAC,4BAA4B,CACjC,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,aAAa,EACvB,yBAAyB,EAAE,eAAe,GACzC,MAAM;IAYT,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,iBAAiB,EAAE,GAAG,iBAAiB,EAAE;IAmBnE,OAAO,CAAC,MAAM,CAAC,UAAU;IAYzB,MAAM,CAAC,YAAY,CACjB,WAAW,EAAE,YAAY,EAAE,EAC3B,gBAAgB,EAAE,YAAY,EAAE,GAC/B,gBAAgB;IAwCnB,MAAM,CAAC,iBAAiB,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAoBzE,MAAM,CAAC,YAAY,CACjB,KAAK,EAAE,iBAAiB,EAAE,EAC1B,QAAQ,EAAE,aAAa,EACvB,yBAAyB,EAAE,eAAe,EAC1C,MAAM,GAAE;QAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAA;KAAM,GACzC,YAAY,EAAE;IAgDjB,MAAM,CAAC,4BAA4B,CACjC,KAAK,EAAE,iBAAiB,EAAE,EAC1B,QAAQ,EAAE,aAAa,EACvB,yBAAyB,EAAE,eAAe,GACzC,YAAY,EAAE;IAMjB,MAAM,CAAC,WAAW,IAAI,eAAe,EAAE;IAevC,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,IAAI;CAKtD"}