[Resolver] Selector performance (elastic#72380) (elastic#72434)

* Memoize various selectors
* Improve performance of the selectors that calculate the `aria-flowto` attribute.
* more tests.

x-pack/plugins/security_solution/common/endpoint/types.ts

@@ -482,7 +482,6 @@ export interface LegacyEndpointEvent {
     type: string;
     version: string;
   };
-  process?: object;
   rule?: object;
   user?: object;
   event?: {

x-pack/plugins/security_solution/public/resolver/models/indexed_process_tree/index.ts

@@ -4,6 +4,8 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
+/* eslint-disable no-shadow */
+
 import { uniquePidForProcess, uniqueParentPidForProcess, orderByTime } from '../process_event';
 import { IndexedProcessTree } from '../../types';
 import { ResolverEvent } from '../../../../common/endpoint/types';
@@ -24,16 +26,15 @@ export function factory(
     const uniqueProcessPid = uniquePidForProcess(process);
     idToValue.set(uniqueProcessPid, process);
 
-    const uniqueParentPid = uniqueParentPidForProcess(process);
-    // if its defined and not ''
-    if (uniqueParentPid) {
-      let siblings = idToChildren.get(uniqueParentPid);
-      if (!siblings) {
-        siblings = [];
-        idToChildren.set(uniqueParentPid, siblings);
-      }
-      siblings.push(process);
+    // NB: If the value was null or undefined, use `undefined`
+    const uniqueParentPid: string | undefined = uniqueParentPidForProcess(process) ?? undefined;
+
+    let childrenWithTheSameParent = idToChildren.get(uniqueParentPid);
+    if (!childrenWithTheSameParent) {
+      childrenWithTheSameParent = [];
+      idToChildren.set(uniqueParentPid, childrenWithTheSameParent);
     }
+    childrenWithTheSameParent.push(process);
   }
 
   // sort the children of each node
@@ -50,9 +51,8 @@ export function factory(
 /**
  * Returns an array with any children `ProcessEvent`s of the passed in `process`
  */
-export function children(tree: IndexedProcessTree, process: ResolverEvent): ResolverEvent[] {
-  const id = uniquePidForProcess(process);
-  const currentProcessSiblings = tree.idToChildren.get(id);
+export function children(tree: IndexedProcessTree, parentID: string | undefined): ResolverEvent[] {
+  const currentProcessSiblings = tree.idToChildren.get(parentID);
   return currentProcessSiblings === undefined ? [] : currentProcessSiblings;
 }
 
@@ -78,31 +78,6 @@ export function parent(
   }
 }
 
-/**
- * Returns the following sibling
- */
-export function nextSibling(
-  tree: IndexedProcessTree,
-  sibling: ResolverEvent
-): ResolverEvent | undefined {
-  const parentNode = parent(tree, sibling);
-  if (parentNode) {
-    // The siblings of `sibling` are the children of its parent.
-    const siblings = children(tree, parentNode);
-
-    // Find the sibling
-    const index = siblings.indexOf(sibling);
-
-    // if the sibling wasn't found, or if it was the last element in the array, return undefined
-    if (index === -1 || index === siblings.length - 1) {
-      return undefined;
-    }
-
-    // return the next sibling
-    return siblings[index + 1];
-  }
-}
-
 /**
  * Number of processes in the tree
  */
@@ -133,6 +108,8 @@ export function root(tree: IndexedProcessTree) {
 export function* levelOrder(tree: IndexedProcessTree) {
   const rootNode = root(tree);
   if (rootNode !== null) {
-    yield* baseLevelOrder(rootNode, children.bind(null, tree));
+    yield* baseLevelOrder(rootNode, (parentNode: ResolverEvent): ResolverEvent[] =>
+      children(tree, uniquePidForProcess(parentNode))
+    );
   }
 }

x-pack/plugins/security_solution/public/resolver/models/indexed_process_tree/isometric_taxi_layout.ts

@@ -19,6 +19,7 @@ import * as event from '../../../../common/endpoint/models/event';
 import { ResolverEvent } from '../../../../common/endpoint/types';
 import * as model from './index';
 import { getFriendlyElapsedTime as elapsedTime } from '../../lib/date';
+import { uniquePidForProcess } from '../process_event';
 
 /**
  * Graph the process tree
@@ -146,10 +147,12 @@ function widthsOfProcessSubtrees(indexedProcessTree: IndexedProcessTree): Proces
     return widths;
   }
 
-  const processesInReverseLevelOrder = [...model.levelOrder(indexedProcessTree)].reverse();
+  const processesInReverseLevelOrder: ResolverEvent[] = [
+    ...model.levelOrder(indexedProcessTree),
+  ].reverse();
 
   for (const process of processesInReverseLevelOrder) {
-    const children = model.children(indexedProcessTree, process);
+    const children = model.children(indexedProcessTree, uniquePidForProcess(process));
 
     const sumOfWidthOfChildren = function sumOfWidthOfChildren() {
       return children.reduce(function sum(currentValue, child) {
@@ -226,7 +229,7 @@ function processEdgeLineSegments(
       metadata: edgeLineMetadata,
     };
 
-    const siblings = model.children(indexedProcessTree, parent);
+    const siblings = model.children(indexedProcessTree, uniquePidForProcess(parent));
     const isFirstChild = process === siblings[0];
 
     if (metadata.isOnlyChild) {
@@ -420,7 +423,7 @@ function* levelOrderWithWidths(
         parentWidth,
       };
 
-      const siblings = model.children(tree, parent);
+      const siblings = model.children(tree, uniquePidForProcess(parent));
       if (siblings.length === 1) {
         metadata.isOnlyChild = true;
         metadata.lastChildWidth = width;

x-pack/plugins/security_solution/public/resolver/store/camera/selectors.ts

@@ -164,7 +164,8 @@ export const scale: (state: CameraState) => (time: number) => Vector2 = createSe
         scalingConstants.maximum
       );
 
-      return (time) => {
+      // memoizing this so the vector returned will be the same object reference if called with the same `time`.
+      return defaultMemoize((time) => {
         /**
          * If the animation has completed, return the `scaleNotCountingAnimation`, as
          * the animation always completes with the scale set back at starting value.
@@ -247,12 +248,13 @@ export const scale: (state: CameraState) => (time: number) => Vector2 = createSe
            */
           return [lerpedScale, lerpedScale];
         }
-      };
+      });
     } else {
       /**
        * The scale should be the same in both axes.
+       * Memoizing this so the vector returned will be the same object reference every time.
        */
-      return () => [scaleNotCountingAnimation, scaleNotCountingAnimation];
+      return defaultMemoize(() => [scaleNotCountingAnimation, scaleNotCountingAnimation]);
     }
 
     /**
@@ -277,22 +279,26 @@ export const clippingPlanes: (
 ) => (time: number) => ClippingPlanes = createSelector(
   (state) => state.rasterSize,
   scale,
-  (rasterSize, scaleAtTime) => (time: number) => {
-    const [scaleX, scaleY] = scaleAtTime(time);
-    const renderWidth = rasterSize[0];
-    const renderHeight = rasterSize[1];
-    const clippingPlaneRight = renderWidth / 2 / scaleX;
-    const clippingPlaneTop = renderHeight / 2 / scaleY;
-
-    return {
-      renderWidth,
-      renderHeight,
-      clippingPlaneRight,
-      clippingPlaneTop,
-      clippingPlaneLeft: -clippingPlaneRight,
-      clippingPlaneBottom: -clippingPlaneTop,
-    };
-  }
+  (rasterSize, scaleAtTime) =>
+    /**
+     * memoizing this for object reference equality.
+     */
+    defaultMemoize((time: number) => {
+      const [scaleX, scaleY] = scaleAtTime(time);
+      const renderWidth = rasterSize[0];
+      const renderHeight = rasterSize[1];
+      const clippingPlaneRight = renderWidth / 2 / scaleX;
+      const clippingPlaneTop = renderHeight / 2 / scaleY;
+
+      return {
+        renderWidth,
+        renderHeight,
+        clippingPlaneRight,
+        clippingPlaneTop,
+        clippingPlaneLeft: -clippingPlaneRight,
+        clippingPlaneBottom: -clippingPlaneTop,
+      };
+    })
 );
 
 /**
@@ -323,7 +329,10 @@ export const translation: (state: CameraState) => (time: number) => Vector2 = cr
   scale,
   (state) => state.animation,
   (panning, translationNotCountingCurrentPanning, scaleAtTime, animation) => {
-    return (time: number) => {
+    /**
+     * Memoizing this for object reference equality.
+     */
+    return defaultMemoize((time: number) => {
       const [scaleX, scaleY] = scaleAtTime(time);
       if (animation !== undefined && animationIsActive(animation, time)) {
         return vector2.lerp(
@@ -343,7 +352,7 @@ export const translation: (state: CameraState) => (time: number) => Vector2 = cr
       } else {
         return translationNotCountingCurrentPanning;
       }
-    };
+    });
   }
 );
 
@@ -357,7 +366,10 @@ export const inverseProjectionMatrix: (
   clippingPlanes,
   translation,
   (clippingPlanesAtTime, translationAtTime) => {
-    return (time: number) => {
+    /**
+     * Memoizing this for object reference equality (and reduced memory churn.)
+     */
+    return defaultMemoize((time: number) => {
       const {
         renderWidth,
         renderHeight,
@@ -404,7 +416,7 @@ export const inverseProjectionMatrix: (
         translateForCamera,
         multiply(scaleToClippingPlaneDimensions, multiply(invertY, screenToNDC))
       );
-    };
+    });
   }
 );
 
@@ -415,7 +427,8 @@ export const viewableBoundingBox: (state: CameraState) => (time: number) => AABB
   clippingPlanes,
   inverseProjectionMatrix,
   (clippingPlanesAtTime, matrixAtTime) => {
-    return (time: number) => {
+    // memoizing this so the AABB returned will be the same object reference if called with the same `time`.
+    return defaultMemoize((time: number) => {
       const { renderWidth, renderHeight } = clippingPlanesAtTime(time);
       const matrix = matrixAtTime(time);
       const bottomLeftCorner: Vector2 = [0, renderHeight];
@@ -424,7 +437,7 @@ export const viewableBoundingBox: (state: CameraState) => (time: number) => AABB
         minimum: vector2.applyMatrix3(bottomLeftCorner, matrix),
         maximum: vector2.applyMatrix3(topRightCorner, matrix),
       };
-    };
+    });
   }
 );
 
@@ -436,6 +449,8 @@ export const projectionMatrix: (state: CameraState) => (time: number) => Matrix3
   clippingPlanes,
   translation,
   (clippingPlanesAtTime, translationAtTime) => {
+    // memoizing this so the matrix returned will be the same object reference if called with the same `time`.
+    // this should also save on some memory allocation
     return defaultMemoize((time: number) => {
       const {
         renderWidth,

x-pack/plugins/security_solution/public/resolver/store/data/selectors.test.ts

@@ -9,6 +9,13 @@ import { DataState } from '../../types';
 import { dataReducer } from './reducer';
 import { DataAction } from './action';
 import { createStore } from 'redux';
+import {
+  mockTreeWithNoAncestorsAnd2Children,
+  mockTreeWith2AncestorsAndNoChildren,
+} from '../mocks/resolver_tree';
+import { uniquePidForProcess } from '../../models/process_event';
+import { EndpointEvent } from '../../../../common/endpoint/types';
+
 describe('data state', () => {
   let actions: DataAction[] = [];
 
@@ -263,4 +270,87 @@ describe('data state', () => {
       });
     });
   });
+  describe('with a tree with no descendants and 2 ancestors', () => {
+    const originID = 'c';
+    const firstAncestorID = 'b';
+    const secondAncestorID = 'a';
+    beforeEach(() => {
+      actions.push({
+        type: 'serverReturnedResolverData',
+        payload: {
+          result: mockTreeWith2AncestorsAndNoChildren({
+            originID,
+            firstAncestorID,
+            secondAncestorID,
+          }),
+          // this value doesn't matter
+          databaseDocumentID: '',
+        },
+      });
+    });
+    it('should have no flowto candidate for the origin', () => {
+      expect(selectors.ariaFlowtoCandidate(state())(originID)).toBe(null);
+    });
+    it('should have no flowto candidate for the first ancestor', () => {
+      expect(selectors.ariaFlowtoCandidate(state())(firstAncestorID)).toBe(null);
+    });
+    it('should have no flowto candidate for the second ancestor ancestor', () => {
+      expect(selectors.ariaFlowtoCandidate(state())(secondAncestorID)).toBe(null);
+    });
+  });
+  describe('with a tree with 2 children and no ancestors', () => {
+    const originID = 'c';
+    const firstChildID = 'd';
+    const secondChildID = 'e';
+    beforeEach(() => {
+      actions.push({
+        type: 'serverReturnedResolverData',
+        payload: {
+          result: mockTreeWithNoAncestorsAnd2Children({ originID, firstChildID, secondChildID }),
+          // this value doesn't matter
+          databaseDocumentID: '',
+        },
+      });
+    });
+    it('should have no flowto candidate for the origin', () => {
+      expect(selectors.ariaFlowtoCandidate(state())(originID)).toBe(null);
+    });
+    it('should use the second child as the flowto candidate for the first child', () => {
+      expect(selectors.ariaFlowtoCandidate(state())(firstChildID)).toBe(secondChildID);
+    });
+    it('should have no flowto candidate for the second child', () => {
+      expect(selectors.ariaFlowtoCandidate(state())(secondChildID)).toBe(null);
+    });
+  });
+  describe('with a tree where the root process has no parent info at all', () => {
+    const originID = 'c';
+    const firstChildID = 'd';
+    const secondChildID = 'e';
+    beforeEach(() => {
+      const tree = mockTreeWithNoAncestorsAnd2Children({ originID, firstChildID, secondChildID });
+      for (const event of tree.lifecycle) {
+        // delete the process.parent key, if present
+        // cast as `EndpointEvent` because `ResolverEvent` can also be `LegacyEndpointEvent` which has no `process` field
+        delete (event as EndpointEvent).process?.parent;
+      }
+
+      actions.push({
+        type: 'serverReturnedResolverData',
+        payload: {
+          result: tree,
+          // this value doesn't matter
+          databaseDocumentID: '',
+        },
+      });
+    });
+    it('should be able to calculate the aria flowto candidates for all processes nodes', () => {
+      const graphables = selectors.graphableProcesses(state());
+      expect(graphables.length).toBe(3);
+      for (const event of graphables) {
+        expect(() => {
+          selectors.ariaFlowtoCandidate(state())(uniquePidForProcess(event));
+        }).not.toThrow();
+      }
+    });
+  });
 });