[Alerting] Return alert execution status rollup from _find API (#81819)

* wip

* wip

* Adding aggregation option to find function and using those results in UI

* Requesting aggregations from client instead of hard-coding in route

* alert_api test

* i18n fix

* Adding functional test

* Adding unit test for filters

* Splitting into two API endpoints

* Fixing test

* Fixing test

* Adding comment

Co-authored-by: Kibana Machine <42973632+kibanamachine@users.noreply.github.com>

Author: ymao1

x-pack/plugins/alerts/common/alert.ts

@@ -46,6 +46,10 @@ export interface AlertAction {
   params: AlertActionParams;
 }
 
+export interface AlertAggregations {
+  alertExecutionStatus: { [status: string]: number };
+}
+
 export interface Alert {
   id: string;
   enabled: boolean;

x-pack/plugins/alerts/server/alerts_client.mock.ts

@@ -11,6 +11,7 @@ export type AlertsClientMock = jest.Mocked<Schema>;
 
 const createAlertsClientMock = () => {
   const mocked: AlertsClientMock = {
+    aggregate: jest.fn(),
     create: jest.fn(),
     get: jest.fn(),
     getAlertState: jest.fn(),

x-pack/plugins/alerts/server/alerts_client/alerts_client.ts

@@ -27,6 +27,7 @@ import {
   SanitizedAlert,
   AlertTaskState,
   AlertInstanceSummary,
+  AlertExecutionStatusValues,
 } from '../types';
 import { validateAlertTypeParams, alertExecutionStatusFromRaw } from '../lib';
 import {
@@ -98,10 +99,25 @@ export interface FindOptions extends IndexType {
   filter?: string;
 }
 
+export interface AggregateOptions extends IndexType {
+  search?: string;
+  defaultSearchOperator?: 'AND' | 'OR';
+  searchFields?: string[];
+  hasReference?: {
+    type: string;
+    id: string;
+  };
+  filter?: string;
+}
+
 interface IndexType {
   [key: string]: unknown;
 }
 
+interface AggregateResult {
+  alertExecutionStatus: { [status: string]: number };
+}
+
 export interface FindResult {
   page: number;
   perPage: number;
@@ -400,6 +416,44 @@ export class AlertsClient {
     };
   }
 
+  public async aggregate({
+    options: { fields, ...options } = {},
+  }: { options?: AggregateOptions } = {}): Promise<AggregateResult> {
+    // Replace this when saved objects supports aggregations https://github.com/elastic/kibana/pull/64002
+    const alertExecutionStatus = await Promise.all(
+      AlertExecutionStatusValues.map(async (status: string) => {
+        const {
+          filter: authorizationFilter,
+          logSuccessfulAuthorization,
+        } = await this.authorization.getFindAuthorizationFilter();
+        const filter = options.filter
+          ? `${options.filter} and alert.attributes.executionStatus.status:(${status})`
+          : `alert.attributes.executionStatus.status:(${status})`;
+        const { total } = await this.unsecuredSavedObjectsClient.find<RawAlert>({
+          ...options,
+          filter:
+            (authorizationFilter && filter
+              ? and([esKuery.fromKueryExpression(filter), authorizationFilter])
+              : authorizationFilter) ?? filter,
+          page: 1,
+          perPage: 0,
+          type: 'alert',
+        });
+
+        logSuccessfulAuthorization();
+
+        return { [status]: total };
+      })
+    );
+
+    return {
+      alertExecutionStatus: alertExecutionStatus.reduce(
+        (acc, curr: { [status: string]: number }) => Object.assign(acc, curr),
+        {}
+      ),
+    };
+  }
+
   public async delete({ id }: { id: string }) {
     let taskIdToRemove: string | undefined | null;
     let apiKeyToInvalidate: string | null = null;

x-pack/plugins/alerts/server/alerts_client/tests/aggregate.test.ts

@@ -0,0 +1,164 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+import { AlertsClient, ConstructorOptions } from '../alerts_client';
+import { savedObjectsClientMock, loggingSystemMock } from '../../../../../../src/core/server/mocks';
+import { taskManagerMock } from '../../../../task_manager/server/mocks';
+import { alertTypeRegistryMock } from '../../alert_type_registry.mock';
+import { alertsAuthorizationMock } from '../../authorization/alerts_authorization.mock';
+import { encryptedSavedObjectsMock } from '../../../../encrypted_saved_objects/server/mocks';
+import { actionsAuthorizationMock } from '../../../../actions/server/mocks';
+import { AlertsAuthorization } from '../../authorization/alerts_authorization';
+import { ActionsAuthorization } from '../../../../actions/server';
+import { getBeforeSetup, setGlobalDate } from './lib';
+import { AlertExecutionStatusValues } from '../../types';
+
+const taskManager = taskManagerMock.createStart();
+const alertTypeRegistry = alertTypeRegistryMock.create();
+const unsecuredSavedObjectsClient = savedObjectsClientMock.create();
+
+const encryptedSavedObjects = encryptedSavedObjectsMock.createClient();
+const authorization = alertsAuthorizationMock.create();
+const actionsAuthorization = actionsAuthorizationMock.create();
+
+const kibanaVersion = 'v7.10.0';
+const alertsClientParams: jest.Mocked<ConstructorOptions> = {
+  taskManager,
+  alertTypeRegistry,
+  unsecuredSavedObjectsClient,
+  authorization: (authorization as unknown) as AlertsAuthorization,
+  actionsAuthorization: (actionsAuthorization as unknown) as ActionsAuthorization,
+  spaceId: 'default',
+  namespace: 'default',
+  getUserName: jest.fn(),
+  createAPIKey: jest.fn(),
+  invalidateAPIKey: jest.fn(),
+  logger: loggingSystemMock.create().get(),
+  encryptedSavedObjectsClient: encryptedSavedObjects,
+  getActionsClient: jest.fn(),
+  getEventLogClient: jest.fn(),
+  kibanaVersion,
+};
+
+beforeEach(() => {
+  getBeforeSetup(alertsClientParams, taskManager, alertTypeRegistry);
+});
+
+setGlobalDate();
+
+describe('aggregate()', () => {
+  const listedTypes = new Set([
+    {
+      actionGroups: [],
+      actionVariables: undefined,
+      defaultActionGroupId: 'default',
+      id: 'myType',
+      name: 'myType',
+      producer: 'myApp',
+    },
+  ]);
+  beforeEach(() => {
+    authorization.getFindAuthorizationFilter.mockResolvedValue({
+      ensureAlertTypeIsAuthorized() {},
+      logSuccessfulAuthorization() {},
+    });
+    unsecuredSavedObjectsClient.find
+      .mockResolvedValueOnce({
+        total: 10,
+        per_page: 0,
+        page: 1,
+        saved_objects: [],
+      })
+      .mockResolvedValueOnce({
+        total: 8,
+        per_page: 0,
+        page: 1,
+        saved_objects: [],
+      })
+      .mockResolvedValueOnce({
+        total: 6,
+        per_page: 0,
+        page: 1,
+        saved_objects: [],
+      })
+      .mockResolvedValueOnce({
+        total: 4,
+        per_page: 0,
+        page: 1,
+        saved_objects: [],
+      })
+      .mockResolvedValueOnce({
+        total: 2,
+        per_page: 0,
+        page: 1,
+        saved_objects: [],
+      });
+    alertTypeRegistry.list.mockReturnValue(listedTypes);
+    authorization.filterByAlertTypeAuthorization.mockResolvedValue(
+      new Set([
+        {
+          id: 'myType',
+          name: 'Test',
+          actionGroups: [{ id: 'default', name: 'Default' }],
+          defaultActionGroupId: 'default',
+          producer: 'alerts',
+          authorizedConsumers: {
+            myApp: { read: true, all: true },
+          },
+        },
+      ])
+    );
+  });
+
+  test('calls saved objects client with given params to perform aggregation', async () => {
+    const alertsClient = new AlertsClient(alertsClientParams);
+    const result = await alertsClient.aggregate({ options: {} });
+    expect(result).toMatchInlineSnapshot(`
+      Object {
+        "alertExecutionStatus": Object {
+          "active": 8,
+          "error": 6,
+          "ok": 10,
+          "pending": 4,
+          "unknown": 2,
+        },
+      }
+    `);
+    expect(unsecuredSavedObjectsClient.find).toHaveBeenCalledTimes(
+      AlertExecutionStatusValues.length
+    );
+    AlertExecutionStatusValues.forEach((status: string, ndx: number) => {
+      expect(unsecuredSavedObjectsClient.find.mock.calls[ndx]).toEqual([
+        {
+          fields: undefined,
+          filter: `alert.attributes.executionStatus.status:(${status})`,
+          page: 1,
+          perPage: 0,
+          type: 'alert',
+        },
+      ]);
+    });
+  });
+
+  test('supports filters when aggregating', async () => {
+    const alertsClient = new AlertsClient(alertsClientParams);
+    await alertsClient.aggregate({ options: { filter: 'someTerm' } });
+
+    expect(unsecuredSavedObjectsClient.find).toHaveBeenCalledTimes(
+      AlertExecutionStatusValues.length
+    );
+    AlertExecutionStatusValues.forEach((status: string, ndx: number) => {
+      expect(unsecuredSavedObjectsClient.find.mock.calls[ndx]).toEqual([
+        {
+          fields: undefined,
+          filter: `someTerm and alert.attributes.executionStatus.status:(${status})`,
+          page: 1,
+          perPage: 0,
+          type: 'alert',
+        },
+      ]);
+    });
+  });
+});

x-pack/plugins/alerts/server/plugin.ts

@@ -33,6 +33,7 @@ import {
 } from '../../../../src/core/server';
 
 import {
+  aggregateAlertRoute,
   createAlertRoute,
   deleteAlertRoute,
   findAlertRoute,
@@ -190,6 +191,7 @@ export class AlertingPlugin {
     // Routes
     const router = core.http.createRouter();
     // Register routes
+    aggregateAlertRoute(router, this.licenseState);
     createAlertRoute(router, this.licenseState);
     deleteAlertRoute(router, this.licenseState);
     findAlertRoute(router, this.licenseState);