@kylincloud/flamegraph 0.35.6

package/src/convert/convertJaegerTraceToProfile.ts

@@ -0,0 +1,97 @@
+/* eslint-disable import/prefer-default-export */
+import groupBy from 'lodash.groupby';
+import map from 'lodash.map';
+import type { Profile, Trace, TraceSpan } from '../models';
+import { deltaDiffWrapperReverse } from '../FlameGraph/decode';
+
+interface Span extends TraceSpan {
+  children: Span[];
+  total: number;
+  self: number;
+}
+
+export function convertJaegerTraceToProfile(trace: Trace): Profile {
+  const resultFlamebearer = {
+    numTicks: 0,
+    maxSelf: 0,
+    names: [] as string[],
+    levels: [] as number[][],
+  };
+
+  // Step 1: converting spans to a tree
+
+  const spans: Record<string, Span> = {};
+  const root: Span = { children: [] } as unknown as Span;
+  (trace.spans as Span[]).forEach((span) => {
+    span.children = [];
+    spans[span.spanID] = span;
+  });
+
+  (trace.spans as Span[]).forEach((span) => {
+    let node = root;
+    if (span.references && span.references.length > 0) {
+      node = spans[span.references[0].spanID] || root;
+    }
+
+    node.children.push(span);
+  });
+
+  // Step 2: group spans with same name
+
+  function groupSpans(span: Span, d: number) {
+    (span.children || []).forEach((x) => groupSpans(x, d + 1));
+
+    let childrenDur = 0;
+    const groups = groupBy(span.children || [], (x) => x.operationName);
+    span.children = map(groups, (group) => {
+      const res = group[0];
+      for (let i = 1; i < group.length; i += 1) {
+        res.duration += group[i].duration;
+      }
+      childrenDur += res.duration;
+      return res;
+    });
+    span.total = span.duration || childrenDur;
+    span.self = Math.max(0, span.total - childrenDur);
+  }
+  groupSpans(root, 0);
+
+  // Step 3: traversing the tree
+
+  function processNode(span: Span, level: number, offset: number) {
+    resultFlamebearer.numTicks ||= span.total;
+    resultFlamebearer.levels[level] ||= [];
+    resultFlamebearer.levels[level].push(offset);
+    resultFlamebearer.levels[level].push(span.total);
+    resultFlamebearer.levels[level].push(span.self);
+    resultFlamebearer.names.push(
+      (span.processID
+        ? `${trace.processes[span.processID].serviceName}: `
+        : '') + (span.operationName || 'total')
+    );
+    resultFlamebearer.levels[level].push(resultFlamebearer.names.length - 1);
+
+    (span.children || []).forEach((x) => {
+      offset += processNode(x, level + 1, offset);
+    });
+    return span.total;
+  }
+
+  processNode(root, 0, 0);
+
+  resultFlamebearer.levels = deltaDiffWrapperReverse(
+    'single',
+    resultFlamebearer.levels
+  );
+
+  return {
+    version: 1,
+    flamebearer: resultFlamebearer,
+    metadata: {
+      format: 'single',
+      units: 'trace_samples',
+      spyName: 'tracing',
+      sampleRate: 1000000,
+    },
+  };
+}

package/src/convert/diffTwoProfiles.ts

@@ -0,0 +1,81 @@
+/* eslint-disable import/prefer-default-export */
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
+import type { Profile, Flamebearer } from './models';
+import {
+  deltaDiffWrapper,
+  deltaDiffWrapperReverse,
+} from '../FlameGraph/decode';
+import { flamebearersToTree } from './flamebearersToTree';
+
+function diffFlamebearer(f1: Flamebearer, f2: Flamebearer): Flamebearer {
+  const result: Flamebearer = {
+    format: 'double',
+    numTicks: f1.numTicks + f2.numTicks,
+    leftTicks: f1.numTicks,
+    rightTicks: f2.numTicks,
+    maxSelf: 100,
+    sampleRate: f1.sampleRate,
+    names: [],
+    levels: [],
+    units: f1.units,
+    spyName: f1.spyName,
+  };
+
+  const tree = flamebearersToTree(f1, f2);
+  const processNode = (
+    node,
+    level: number,
+    offsetLeft: number,
+    offsetRight: number
+  ) => {
+    const { name, children, self, total } = node;
+    result.names.push(name);
+    result.levels[level] ||= [];
+    result.maxSelf = Math.max(result.maxSelf, self[0] || 0, self[1] || 0);
+    result.levels[level] = result.levels[level].concat([
+      offsetLeft,
+      total[0] || 0,
+      self[0] || 0,
+      offsetRight,
+      total[1] || 0,
+      self[1] || 0,
+      result.names.length - 1,
+    ]);
+    for (let i = 0; i < children.length; i += 1) {
+      const [ol, or] = processNode(
+        children[i],
+        level + 1,
+        offsetLeft,
+        offsetRight
+      );
+      offsetLeft += ol;
+      offsetRight += or;
+    }
+    return [total[0] || 0, total[1] || 0];
+  };
+
+  processNode(tree, 0, 0, 0);
+
+  return result;
+}
+
+export function diffTwoProfiles(p1: Profile, p2: Profile): Profile {
+  p1.flamebearer.levels = deltaDiffWrapper('single', p1.flamebearer.levels);
+  p2.flamebearer.levels = deltaDiffWrapper('single', p2.flamebearer.levels);
+  const resultFlamebearer = diffFlamebearer(p1.flamebearer, p2.flamebearer);
+  resultFlamebearer.levels = deltaDiffWrapperReverse(
+    'double',
+    resultFlamebearer.levels
+  );
+  const metadata = { ...p1.metadata };
+  metadata.format = 'double';
+  return {
+    version: 1,
+    flamebearer: resultFlamebearer,
+    metadata,
+    leftTicks: p1.flamebearer.numTicks,
+    rightTicks: p2.flamebearer.numTicks,
+  };
+}

package/src/convert/flamebearersToTree.ts

@@ -0,0 +1,78 @@
+import type { Profile } from '../models';
+
+export interface TreeNode {
+  name: string;
+  key: string;
+  self: number[];
+  total: number[];
+  offset?: number;
+  children: TreeNode[];
+}
+
+export function flamebearersToTree(
+  f1: Profile['flamebearer'],
+  f2?: Profile['flamebearer']
+): TreeNode {
+  const globalLookup: { [key: string]: TreeNode } = {};
+  const treeSpecificLookup: { [key: string]: TreeNode } = {};
+  let root: TreeNode = {
+    name: 'total',
+    children: [],
+    self: [],
+    total: [],
+    key: '/total',
+  };
+
+  (f2 ? [f1, f2] : [f1]).forEach((f, fi) => {
+    for (let i = 0; i < f.levels.length; i += 1) {
+      for (let j = 0; j < f.levels[i].length; j += 4) {
+        const treeSpecificKey: string = [fi, i, j].join('/');
+        const name: string = f.names[f.levels[i][j + 3]];
+        const offset: number = f.levels[i][j + 0];
+        const total: number = f.levels[i][j + 1];
+        const self: number = f.levels[i][j + 2];
+        let parentGlobalKey = '';
+        // searching for parent node
+        if (i !== 0) {
+          const pi = i - 1;
+          const parentLevel = f.levels[pi];
+          for (let k = 0; k < parentLevel.length; k += 4) {
+            const parentOffset = parentLevel[k + 0];
+            const total = parentLevel[k + 1];
+            if (offset >= parentOffset && offset < parentOffset + total) {
+              const parentTreeSpecificKey = [fi, pi, k].join('/');
+              const parentObj = treeSpecificLookup[parentTreeSpecificKey];
+              parentGlobalKey = parentObj.key;
+              break;
+            }
+          }
+        }
+
+        const globalKey = [parentGlobalKey || '', name].join('/');
+        const isNewObject = !globalLookup[globalKey];
+        globalLookup[globalKey] ||= {
+          name,
+          children: [],
+          self: [],
+          total: [],
+          key: globalKey,
+        } as TreeNode;
+        const obj: TreeNode = globalLookup[globalKey];
+        obj.total[fi] ||= 0;
+        obj.total[fi] += total;
+        obj.self[fi] ||= 0;
+        obj.self[fi] += self;
+        treeSpecificLookup[treeSpecificKey] = obj;
+
+        if (parentGlobalKey && isNewObject) {
+          globalLookup[parentGlobalKey].children.push(obj);
+        }
+        if (i === 0) {
+          root = obj;
+        }
+      }
+    }
+  });
+
+  return root;
+}

package/src/convert/sandwichViewProfiles.spec.ts

@@ -0,0 +1,65 @@
+import { treeToFlamebearer, calleesFlamebearer } from './sandwichViewProfiles';
+import { flamebearersToTree } from './flamebearersToTree';
+
+import { tree, singleAppearanceTrees } from './testData';
+import { Flamebearer } from '../models';
+
+const flamebearersProps = {
+  spyName: 'gospy',
+  units: 'samples',
+  format: 'single',
+  numTicks: 400,
+  maxSelf: 150,
+  sampleRate: 100,
+};
+
+describe('Sandwich view profiles', () => {
+  describe('when target function has single tree appearance', () => {
+    it('return correct flamebearer with 0 callees', () => {
+      const f = treeToFlamebearer(tree);
+
+      const resultCalleesFlamebearer = calleesFlamebearer(
+        { ...f, ...flamebearersProps } as Flamebearer,
+        'name-5-2'
+      );
+
+      const treeToMatchOriginalTree = flamebearersToTree(
+        resultCalleesFlamebearer
+      );
+
+      expect(treeToMatchOriginalTree).toMatchObject(singleAppearanceTrees.zero);
+    });
+    it('return correct flamebearer with 1 callee', () => {
+      const f = treeToFlamebearer(tree);
+
+      const resultCalleesFlamebearer = calleesFlamebearer(
+        { ...f, ...flamebearersProps } as Flamebearer,
+        'wwwwwww'
+      );
+
+      const treeToMatchOriginalTree = flamebearersToTree(
+        resultCalleesFlamebearer
+      );
+
+      expect(treeToMatchOriginalTree).toMatchObject(singleAppearanceTrees.one);
+    });
+    it('return correct flamebearer with multiple callees', () => {
+      const f = treeToFlamebearer(tree);
+
+      const resultCalleesFlamebearer = calleesFlamebearer(
+        { ...f, ...flamebearersProps } as Flamebearer,
+        'name-2-2'
+      );
+
+      const treeToMatchOriginalTree = flamebearersToTree(
+        resultCalleesFlamebearer
+      );
+
+      expect(treeToMatchOriginalTree).toMatchObject(
+        singleAppearanceTrees.multiple
+      );
+    });
+  });
+
+  // todo(dogfrogfog): add tests for callers flamegraph when remove top lvl empty node
+});

package/src/convert/sandwichViewProfiles.ts

@@ -0,0 +1,191 @@
+import type { Flamebearer } from '../models';
+import { flamebearersToTree, TreeNode } from './flamebearersToTree';
+
+interface FlamebearerData {
+  maxSelf: number;
+  levels: number[][];
+  names: string[];
+}
+
+export const treeToFlamebearer = (tree: TreeNode): FlamebearerData => {
+  const flamebearerData: FlamebearerData = {
+    maxSelf: 100,
+    names: [],
+    levels: [],
+  };
+
+  const processNode = (node: TreeNode, level: number, offsetLeft: number) => {
+    const { name, children, self, total, offset } = node;
+    flamebearerData.names.push(name);
+    flamebearerData.levels[level] ||= [];
+    flamebearerData.maxSelf = Math.max(flamebearerData.maxSelf, self[0] || 0);
+    flamebearerData.levels[level] = flamebearerData.levels[level].concat([
+      offsetLeft,
+      total[0] || 0,
+      self[0] || 0,
+      flamebearerData.names.length - 1,
+    ]);
+
+    for (let i = 0; i < children.length; i += 1) {
+      const ol = processNode(children[i], level + 1, offsetLeft);
+      offsetLeft += ol;
+    }
+    return offset || total[0] || 0;
+  };
+
+  processNode(tree, 0, 0);
+
+  return flamebearerData;
+};
+
+const arrayToTree = (nodesArray: TreeNode[], total: number): TreeNode => {
+  const result = {} as TreeNode;
+  let nestedObj = result;
+
+  nodesArray.forEach(({ name, ...rest }) => {
+    const nextNode = { name, ...rest, total: [total] };
+    nestedObj.children = [nextNode];
+    nestedObj = nextNode;
+  });
+
+  return result.children[0];
+};
+
+function dedupTree(node: TreeNode) {
+  const childrenMap = new Map<string, TreeNode>();
+  for (let i = 0; i < node.children.length; i += 1) {
+    if (!childrenMap.has(node.children[i].name)) {
+      childrenMap.set(node.children[i].name, node.children[i]);
+    }
+  }
+
+  for (let i = 0; i < node.children.length; i += 1) {
+    const currentNode = node.children[i];
+    const existingNode = childrenMap.get(node.children[i].name);
+    if (existingNode && existingNode !== currentNode) {
+      existingNode.total[0] += currentNode.total[0];
+      existingNode.self[0] += currentNode.self[0];
+      existingNode.children = existingNode.children.concat(
+        currentNode.children
+      );
+    }
+  }
+  node.children = Array.from(childrenMap.values());
+  for (let i = 0; i < node.children.length; i += 1) {
+    dedupTree(node.children[i]);
+  }
+}
+
+export function calleesFlamebearer(
+  f: Flamebearer,
+  nodeName: string
+): Flamebearer {
+  const tree = flamebearersToTree(f);
+  const result: Flamebearer = {
+    format: 'single',
+    numTicks: 0,
+    maxSelf: 100,
+    sampleRate: 100,
+    names: [],
+    levels: [],
+    units: f.units,
+    spyName: f.spyName,
+  };
+
+  const totalNode = {
+    name: nodeName,
+    key: `/${nodeName}`,
+    total: [],
+    self: [0],
+    children: [],
+  } as TreeNode;
+  const processTree = (node: TreeNode) => {
+    if (node.name === nodeName) {
+      result.numTicks += node.total[0];
+
+      totalNode.total = [result.numTicks];
+      totalNode.children = totalNode.children.concat(node.children);
+    }
+    for (let i = 0; i < node.children.length; i += 1) {
+      processTree(node.children[i]);
+    }
+  };
+  processTree(tree);
+  dedupTree(totalNode);
+
+  return { ...result, ...treeToFlamebearer(totalNode) };
+}
+
+export function callersFlamebearer(
+  f: Flamebearer,
+  nodeName: string
+): Flamebearer {
+  const tree = flamebearersToTree(f);
+  const result: Flamebearer = {
+    format: 'single',
+    maxSelf: 100,
+    sampleRate: 100,
+    numTicks: 0,
+    names: [],
+    levels: [],
+    units: f.units,
+    spyName: f.spyName,
+  };
+
+  const targetFunctionTotals: number[] = [];
+  const subtrees: TreeNode[][] = [];
+
+  const totalNode = {
+    name: nodeName,
+    key: `/${nodeName}`,
+    total: [0],
+    self: [0],
+    children: [],
+  } as TreeNode;
+  const processTree = (node: TreeNode, parentNodes: TreeNode[] = []) => {
+    const currentSubtree = parentNodes.concat([
+      { ...node, children: [] } as TreeNode,
+    ]);
+
+    if (node.name === nodeName) {
+      subtrees.push(currentSubtree);
+      targetFunctionTotals.push(node.total[0]);
+      result.numTicks += node.total[0];
+    }
+
+    for (let i = 0; i < node.children.length; i += 1) {
+      processTree(node.children[i], currentSubtree);
+    }
+  };
+  processTree(tree);
+
+  // 1. we first make a regular tree
+  subtrees.forEach((v, i) => {
+    totalNode.children.push(arrayToTree(v.reverse(), targetFunctionTotals[i]));
+  });
+
+  // 2. that allows us to use the same dedup function
+  dedupTree(totalNode);
+
+  const flamebearer = treeToFlamebearer(totalNode);
+
+  // 3. then we reverse levels so that tree goes from bottom to top
+  flamebearer.levels = flamebearer.levels.reverse().slice(0, -1);
+
+  return { ...result, ...flamebearer };
+}
+
+export function calleesProfile(f: Flamebearer, nodeName: string): Flamebearer {
+  const copy = JSON.parse(JSON.stringify(f));
+  const calleesResultFlamebearer = calleesFlamebearer(copy, nodeName);
+
+  return calleesResultFlamebearer;
+}
+
+export function callersProfile(f: Flamebearer, nodeName: string): Flamebearer {
+  const copy = JSON.parse(JSON.stringify(f));
+
+  const callersResultFlamebearer = callersFlamebearer(copy, nodeName);
+
+  return callersResultFlamebearer;
+}

package/src/convert/subtract.ts

@@ -0,0 +1,87 @@
+import type { Profile } from '../models';
+import {
+  decodeFlamebearer,
+  deltaDiffWrapperReverse,
+} from '../FlameGraph/decode';
+import { flamebearersToTree, TreeNode } from './flamebearersToTree';
+
+function subtractFlamebearer(
+  f1: Profile['flamebearer'],
+  f2: Profile['flamebearer']
+): Profile['flamebearer'] {
+  const result: Profile['flamebearer'] = {
+    numTicks: 0,
+    maxSelf: 0,
+    names: [],
+    levels: [],
+  };
+
+  const tree = flamebearersToTree(f1, f2);
+
+  const updateNumbers = (node: TreeNode): number => {
+    // self is easy
+    node.self[0] = Math.max((node.self[0] || 0) - (node.self[1] || 0), 0);
+    result.numTicks += node.self[0];
+
+    // total needs to be recalculated using children
+    if (node.children.length === 0) {
+      node.total[0] = Math.max((node.total[0] || 0) - (node.total[1] || 0), 0);
+    } else {
+      let total = node.self[0];
+      for (let i = 0; i < node.children.length; i += 1) {
+        total += updateNumbers(node.children[i]);
+      }
+      node.total[0] = total;
+    }
+
+    return node.total[0];
+  };
+
+  updateNumbers(tree);
+
+  const processNode = (node: TreeNode, level: number, offset: number) => {
+    const { name, children, self, total } = node;
+    result.levels[level] ||= [];
+    const newSelf = self[0];
+    const newTotal = total[0];
+    result.maxSelf = Math.max(result.maxSelf, newSelf);
+    if (newTotal === 0) {
+      return 0;
+    }
+    result.names.push(name);
+    result.levels[level] = result.levels[level].concat([
+      offset,
+      newTotal,
+      newSelf,
+      result.names.length - 1,
+    ]);
+    for (let i = 0; i < children.length; i += 1) {
+      const offsetAddition = processNode(children[i], level + 1, offset);
+      offset += offsetAddition;
+    }
+    return newTotal;
+  };
+
+  processNode(tree, 0, 0);
+  return result;
+}
+
+// this functions expects two compressed (before delta diff) profiles,
+//   and returns a compressed profile
+export function subtract(p1: Profile, p2: Profile): Profile {
+  p1 = decodeFlamebearer(p1);
+  p2 = decodeFlamebearer(p2);
+
+  const resultFlamebearer = subtractFlamebearer(p1.flamebearer, p2.flamebearer);
+  resultFlamebearer.levels = deltaDiffWrapperReverse(
+    'single',
+    resultFlamebearer.levels
+  );
+  const metadata = { ...p1.metadata };
+  metadata.format = 'single';
+  return {
+    version: 1,
+    flamebearer: resultFlamebearer,
+    metadata,
+  };
+}