Implemented Alerting health status pusher by using task manager and status pooler for Kibana status plugins 'kibanahost/api/status'

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

@@ -19,6 +19,7 @@ export interface ActionGroup {
 export interface AlertingFrameworkHealth {
   isSufficientlySecure: boolean;
   hasPermanentEncryptionKey: boolean;
+  hasDecryptionFailures: boolean;
 }
 
 export const BASE_ALERT_API_PATH = '/api/alerts';

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

@@ -26,6 +26,7 @@ const createAlertsClientMock = () => {
     unmuteInstance: jest.fn(),
     listAlertTypes: jest.fn(),
     getAlertInstanceSummary: jest.fn(),
+    hasDecryptionFailures: jest.fn(),
   };
   return mocked;
 };

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

@@ -2931,6 +2931,161 @@ describe('find()', () => {
   });
 });
 
+describe('hasDecryptionFailures()', () => {
+  const listedTypes = new Set([
+    {
+      actionGroups: [],
+      actionVariables: undefined,
+      defaultActionGroupId: 'default',
+      id: 'myType',
+      name: 'myType',
+      producer: 'myApp',
+    },
+  ]);
+  beforeAll(() => {
+    alertTypeRegistry.list.mockReturnValue(listedTypes);
+  });
+
+  test('return true if some of alerts has a decryption error', async () => {
+    unsecuredSavedObjectsClient.find.mockResolvedValueOnce({
+      total: 2,
+      per_page: 10,
+      page: 1,
+      saved_objects: [
+        {
+          id: '1',
+          type: 'alert',
+          attributes: {
+            alertTypeId: 'myType',
+            schedule: { interval: '10s' },
+            params: {
+              bar: true,
+            },
+            createdAt: new Date().toISOString(),
+            actions: [
+              {
+                group: 'default',
+                actionRef: 'action_0',
+                params: {
+                  foo: true,
+                },
+              },
+            ],
+            executionStatus: {
+              status: 'error',
+              lastExecutionDate: new Date().toISOString(),
+              error: {
+                reason: 'decrypt',
+                message: 'Failed decrypt',
+              },
+            },
+          },
+          score: 1,
+          references: [
+            {
+              name: 'action_0',
+              type: 'action',
+              id: '1',
+            },
+          ],
+        },
+        {
+          id: '2',
+          type: 'alert',
+          attributes: {
+            alertTypeId: 'myType',
+            schedule: { interval: '1s' },
+            params: {
+              bar: true,
+            },
+            createdAt: new Date().toISOString(),
+            actions: [],
+            executionStatus: {
+              status: 'ok',
+              lastExecutionDate: new Date().toISOString(),
+            },
+          },
+          score: 1,
+          references: [],
+        },
+      ],
+    });
+    const alertsClient = new AlertsClient(alertsClientParams);
+    const result = await alertsClient.hasDecryptionFailures();
+    expect(result).toBe(true);
+    expect(unsecuredSavedObjectsClient.find).toHaveBeenCalledTimes(1);
+  });
+
+  test('return false if no alerts with a decryption error', async () => {
+    unsecuredSavedObjectsClient.find.mockResolvedValueOnce({
+      total: 2,
+      per_page: 10,
+      page: 1,
+      saved_objects: [
+        {
+          id: '1',
+          type: 'alert',
+          attributes: {
+            alertTypeId: 'myType',
+            schedule: { interval: '10s' },
+            params: {
+              bar: true,
+            },
+            createdAt: new Date().toISOString(),
+            actions: [
+              {
+                group: 'default',
+                actionRef: 'action_0',
+                params: {
+                  foo: true,
+                },
+              },
+            ],
+            executionStatus: {
+              status: 'error',
+              lastExecutionDate: new Date().toISOString(),
+              error: {
+                reason: 'unknown',
+                message: 'Failed',
+              },
+            },
+          },
+          score: 1,
+          references: [
+            {
+              name: 'action_0',
+              type: 'action',
+              id: '1',
+            },
+          ],
+        },
+        {
+          id: '2',
+          type: 'alert',
+          attributes: {
+            alertTypeId: 'myType',
+            schedule: { interval: '1s' },
+            params: {
+              bar: true,
+            },
+            createdAt: new Date().toISOString(),
+            actions: [],
+            executionStatus: {
+              status: 'ok',
+              lastExecutionDate: new Date().toISOString(),
+            },
+          },
+          score: 1,
+          references: [],
+        },
+      ],
+    });
+    const alertsClient = new AlertsClient(alertsClientParams);
+    const result = await alertsClient.hasDecryptionFailures();
+    expect(result).toBe(false);
+  });
+});
+
 describe('delete()', () => {
   let alertsClient: AlertsClient;
   const existingAlert = {

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

@@ -396,6 +396,17 @@ export class AlertsClient {
     };
   }
 
+  public async hasDecryptionFailures(): Promise<boolean> {
+    const { saved_objects: data } = await this.unsecuredSavedObjectsClient.find<RawAlert>({
+      filter: 'alert.attributes.executionStatus.status:error',
+      fields: ['executionStatus'],
+      type: 'alert',
+    });
+    return (
+      data.filter((item) => item.attributes.executionStatus.error?.reason === 'decrypt').length > 0
+    );
+  }
+
   public async delete({ id }: { id: string }) {
     let taskIdToRemove: string | undefined | null;
     let apiKeyToInvalidate: string | null = null;

x-pack/plugins/alerts/server/health/get_state.test.ts

@@ -0,0 +1,74 @@
+/*
+ * 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 { taskManagerMock } from '../../../task_manager/server/task_manager.mock';
+import { healthStatus$ } from '.';
+import { TaskStatus } from '../../../task_manager/server';
+
+describe('healthStatus$()', () => {
+  const mockTaskManager = taskManagerMock.start();
+
+  it('should return an object with the "unavailable" level and proper summary of "Alerting framework is unhealthy"', async () => {
+    mockTaskManager.get.mockReturnValue(
+      new Promise((_resolve, _reject) => {
+        return {
+          id: 'test',
+          attempts: 0,
+          status: TaskStatus.Running,
+          version: '123',
+          runAt: new Date(),
+          scheduledAt: new Date(),
+          startedAt: new Date(),
+          retryAt: new Date(Date.now() + 5 * 60 * 1000),
+          state: {
+            runs: 1,
+            isHealthy: false,
+          },
+          taskType: 'alerting:alerting_health_check',
+          params: {
+            alertId: '1',
+          },
+          ownerId: null,
+        };
+      })
+    );
+    healthStatus$(mockTaskManager).subscribe(
+      (val: { level: Readonly<unknown>; summary: string }) => {
+        expect(val.level).toBe(false);
+      }
+    );
+  });
+
+  it('should return an object with the "available" level and proper summary of "Alerting framework is healthy"', async () => {
+    mockTaskManager.get.mockReturnValue(
+      new Promise((_resolve, _reject) => {
+        return {
+          id: 'test',
+          attempts: 0,
+          status: TaskStatus.Running,
+          version: '123',
+          runAt: new Date(),
+          scheduledAt: new Date(),
+          startedAt: new Date(),
+          retryAt: new Date(Date.now() + 5 * 60 * 1000),
+          state: {
+            runs: 1,
+            isHealthy: true,
+          },
+          taskType: 'alerting:alerting_health_check',
+          params: {
+            alertId: '1',
+          },
+          ownerId: null,
+        };
+      })
+    );
+    healthStatus$(mockTaskManager).subscribe(
+      (val: { level: Readonly<unknown>; summary: string }) => {
+        expect(val.level).toBe(true);
+      }
+    );
+  });
+});

x-pack/plugins/alerts/server/health/get_state.ts

@@ -0,0 +1,51 @@
+/*
+ * 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 { interval } from 'rxjs';
+import { catchError, switchMap } from 'rxjs/operators';
+import { get } from 'lodash';
+import { ServiceStatusLevels } from '../../../../../src/core/server';
+import { TaskManagerStartContract } from '../../../task_manager/server';
+import { HEALTH_TASK_ID } from './task';
+
+async function getLatestTaskState(taskManager: TaskManagerStartContract) {
+  try {
+    const result = await taskManager.get(HEALTH_TASK_ID);
+    return result;
+  } catch (err) {
+    const errMessage = err && err.message ? err.message : err.toString();
+    if (!errMessage.includes('NotInitialized')) {
+      throw err;
+    }
+  }
+
+  return null;
+}
+
+export const healthStatus$ = (taskManager: TaskManagerStartContract) => {
+  return interval(1000).pipe(
+    switchMap(async () => {
+      const doc = await getLatestTaskState(taskManager);
+      const body = get(doc, 'state');
+      if (body?.isHealthy) {
+        return {
+          level: ServiceStatusLevels.available,
+          summary: 'Alerting framework is healthy',
+        };
+      } else {
+        return {
+          level: ServiceStatusLevels.unavailable,
+          summary: 'Alerting framework is unhealthy',
+        };
+      }
+    }),
+    catchError(async (error) => ({
+      level: ServiceStatusLevels.unavailable,
+      summary: `Alerting framework is unhealthy`,
+      meta: { error },
+    }))
+  );
+};

x-pack/plugins/alerts/server/health/index.ts

@@ -0,0 +1,8 @@
+/*
+ * 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.
+ */
+
+export { healthStatus$ } from './get_state';
+export { scheduleAlertingHealthCheck, initializeAlertingHealth } from './task';