[ML] Alerting rule for Anomaly Detection jobs monitoring

x-pack/plugins/ml/common/constants/alerts.ts

@@ -5,47 +5,15 @@
  * 2.0.
  */
 
-import { i18n } from '@kbn/i18n';
-import { ActionGroup } from '../../../alerting/common';
-import { MINIMUM_FULL_LICENSE } from '../license';
-import { PLUGIN_ID } from './app';
-
 export const ML_ALERT_TYPES = {
   ANOMALY_DETECTION: 'xpack.ml.anomaly_detection_alert',
+  AD_JOBS_HEALTH: 'xpack.ml.anomaly_detection_jobs_health',
 } as const;
 
 export type MlAlertType = typeof ML_ALERT_TYPES[keyof typeof ML_ALERT_TYPES];
 
-export const ANOMALY_SCORE_MATCH_GROUP_ID = 'anomaly_score_match';
-export type AnomalyScoreMatchGroupId = typeof ANOMALY_SCORE_MATCH_GROUP_ID;
-export const THRESHOLD_MET_GROUP: ActionGroup<AnomalyScoreMatchGroupId> = {
-  id: ANOMALY_SCORE_MATCH_GROUP_ID,
-  name: i18n.translate('xpack.ml.anomalyDetectionAlert.actionGroupName', {
-    defaultMessage: 'Anomaly score matched the condition',
-  }),
-};
-
-export const ML_ALERT_TYPES_CONFIG: Record<
-  MlAlertType,
-  {
-    name: string;
-    actionGroups: Array<ActionGroup<AnomalyScoreMatchGroupId>>;
-    defaultActionGroupId: AnomalyScoreMatchGroupId;
-    minimumLicenseRequired: string;
-    producer: string;
-  }
-> = {
-  [ML_ALERT_TYPES.ANOMALY_DETECTION]: {
-    name: i18n.translate('xpack.ml.anomalyDetectionAlert.name', {
-      defaultMessage: 'Anomaly detection alert',
-    }),
-    actionGroups: [THRESHOLD_MET_GROUP],
-    defaultActionGroupId: ANOMALY_SCORE_MATCH_GROUP_ID,
-    minimumLicenseRequired: MINIMUM_FULL_LICENSE,
-    producer: PLUGIN_ID,
-  },
-};
-
 export const ALERT_PREVIEW_SAMPLE_SIZE = 5;
 
 export const TOP_N_BUCKETS_COUNT = 1;
+
+export const ALL_JOBS_SELECTION = '*';

x-pack/plugins/ml/common/types/alerts.ts

@@ -108,3 +108,30 @@ export type MlAnomalyDetectionAlertRule = Omit<Alert<MlAnomalyDetectionAlertPara
 export interface JobAlertingRuleStats {
   alerting_rules?: MlAnomalyDetectionAlertRule[];
 }
+
+interface CommonHealthCheckConfig {
+  enabled: boolean;
+}
+
+export type MlAnomalyDetectionJobsHealthRuleParams = {
+  includeJobs: {
+    jobIds?: string[];
+    groupIds?: string[];
+  };
+  excludeJobs?: {
+    jobIds?: string[];
+    groupIds?: string[];
+  };
+  testsConfig?: {
+    dataFeed?: CommonHealthCheckConfig;
+    mml?: CommonHealthCheckConfig;
+    delayedData?: CommonHealthCheckConfig & {
+      docsCount?: number;
+      timeInterval?: string;
+    };
+    behindRealtime?: CommonHealthCheckConfig & {
+      timeInterval?: string;
+    };
+    errorMessages?: CommonHealthCheckConfig;
+  };
+} & AlertTypeParams;

x-pack/plugins/ml/public/alerting/job_selector.tsx

@@ -5,12 +5,13 @@
  * 2.0.
  */
 
-import React, { FC, useCallback, useEffect, useMemo, useState } from 'react';
+import React, { FC, ReactNode, useCallback, useEffect, useMemo, useState } from 'react';
 import { i18n } from '@kbn/i18n';
 import { FormattedMessage } from '@kbn/i18n/react';
 import { EuiComboBox, EuiComboBoxOptionOption, EuiComboBoxProps, EuiFormRow } from '@elastic/eui';
 import { JobId } from '../../common/types/anomaly_detection_jobs';
 import { MlApiServices } from '../application/services/ml_api_service';
+import { ALL_JOBS_SELECTION } from '../../common/constants/alerts';
 
 interface JobSelection {
   jobIds?: JobId[];
@@ -25,13 +26,18 @@ export interface JobSelectorControlProps {
    * Validation is handled by alerting framework
    */
   errors: string[];
+  /** Enables multiple selection of jobs and groups */
+  multiSelect?: boolean;
+  label?: ReactNode;
 }
 
 export const JobSelectorControl: FC<JobSelectorControlProps> = ({
   jobsAndGroupIds,
   onChange,
   adJobsApiService,
   errors,
+  multiSelect = false,
+  label,
 }) => {
   const [options, setOptions] = useState<Array<EuiComboBoxOptionOption<string>>>([]);
   const jobIds = useMemo(() => new Set(), []);
@@ -60,34 +66,66 @@ export const JobSelectorControl: FC<JobSelectorControlProps> = ({
       });
 
       setOptions([
+        ...(multiSelect
+          ? [
+              {
+                label: i18n.translate('xpack.ml.jobSelector.selectAllGroupLabel', {
+                  defaultMessage: 'Select all',
+                }),
+                options: [
+                  {
+                    label: i18n.translate('xpack.ml.jobSelector.selectAllOptionLabel', {
+                      defaultMessage: '*',
+                    }),
+                    value: ALL_JOBS_SELECTION,
+                  },
+                ],
+              },
+            ]
+          : []),
         {
           label: i18n.translate('xpack.ml.jobSelector.jobOptionsLabel', {
             defaultMessage: 'Jobs',
           }),
           options: jobIdOptions.map((v) => ({ label: v })),
         },
+        ...(multiSelect
+          ? [
+              {
+                label: i18n.translate('xpack.ml.jobSelector.groupOptionsLabel', {
+                  defaultMessage: 'Groups',
+                }),
+                options: groupIdOptions.map((v) => ({ label: v })),
+              },
+            ]
+          : []),
       ]);
     } catch (e) {
       // TODO add error handling
     }
   }, [adJobsApiService]);
 
   const onSelectionChange: EuiComboBoxProps<string>['onChange'] = useCallback(
-    (selectionUpdate) => {
+    ((selectionUpdate) => {
+      if (selectionUpdate.some((selectedOption) => selectedOption.value === ALL_JOBS_SELECTION)) {
+        onChange({ jobIds: [ALL_JOBS_SELECTION] });
+        return;
+      }
+
       const selectedJobIds: JobId[] = [];
       const selectedGroupIds: string[] = [];
-      selectionUpdate.forEach(({ label }: { label: string }) => {
-        if (jobIds.has(label)) {
-          selectedJobIds.push(label);
-        } else if (groupIds.has(label)) {
-          selectedGroupIds.push(label);
+      selectionUpdate.forEach(({ label: selectedLabel }: { label: string }) => {
+        if (jobIds.has(selectedLabel)) {
+          selectedJobIds.push(selectedLabel);
+        } else if (groupIds.has(selectedLabel)) {
+          selectedGroupIds.push(selectedLabel);
         }
       });
       onChange({
         ...(selectedJobIds.length > 0 ? { jobIds: selectedJobIds } : {}),
         ...(selectedGroupIds.length > 0 ? { groupIds: selectedGroupIds } : {}),
       });
-    },
+    }) as Exclude<EuiComboBoxProps<string>['onChange'], undefined>,
     [jobIds, groupIds]
   );
 
@@ -99,13 +137,18 @@ export const JobSelectorControl: FC<JobSelectorControlProps> = ({
     <EuiFormRow
       fullWidth
       label={
-        <FormattedMessage id="xpack.ml.jobSelector.formControlLabel" defaultMessage="Select job" />
+        label ?? (
+          <FormattedMessage
+            id="xpack.ml.jobSelector.formControlLabel"
+            defaultMessage="Select job"
+          />
+        )
       }
       isInvalid={!!errors?.length}
       error={errors}
     >
       <EuiComboBox<string>
-        singleSelection
+        singleSelection={!multiSelect}
         selectedOptions={selectedOptions}
         options={options}
         onChange={onSelectionChange}

x-pack/plugins/ml/public/alerting/jobs_health_rule/anomaly_detection_jobs_health_rule_trigger.tsx

@@ -0,0 +1,75 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import React, { FC, useCallback, useMemo } from 'react';
+import { EuiForm, EuiSpacer } from '@elastic/eui';
+import { FormattedMessage } from '@kbn/i18n/react';
+import { AlertTypeParamsExpressionProps } from '../../../../triggers_actions_ui/public';
+import { MlAnomalyDetectionJobsHealthRuleParams } from '../../../common/types/alerts';
+import { JobSelectorControl } from '../job_selector';
+import { jobsApiProvider } from '../../application/services/ml_api_service/jobs';
+import { HttpService } from '../../application/services/http_service';
+import { useMlKibana } from '../../application/contexts/kibana';
+import { TestsSelectionControl } from './tests_selection_control';
+
+export type MlAnomalyAlertTriggerProps = AlertTypeParamsExpressionProps<MlAnomalyDetectionJobsHealthRuleParams>;
+
+const AnomalyDetectionJobsHealthRuleTrigger: FC<MlAnomalyAlertTriggerProps> = ({
+  alertParams,
+  setAlertParams,
+  errors,
+}) => {
+  const {
+    services: { http },
+  } = useMlKibana();
+  const mlHttpService = useMemo(() => new HttpService(http), [http]);
+  const adJobsApiService = useMemo(() => jobsApiProvider(mlHttpService), [mlHttpService]);
+
+  const jobsAndGroupIds: string[] = useMemo(
+    () => (Object.values(alertParams.includeJobs ?? {}) as string[][]).flat(),
+    [alertParams.includeJobs]
+  );
+
+  const onAlertParamChange = useCallback(
+    <T extends keyof MlAnomalyDetectionJobsHealthRuleParams>(param: T) => (
+      update: MlAnomalyDetectionJobsHealthRuleParams[T]
+    ) => {
+      setAlertParams(param, update);
+    },
+    []
+  );
+
+  return (
+    <EuiForm data-test-subj={'mlJobsHealthAlertingRuleForm'}>
+      <JobSelectorControl
+        jobsAndGroupIds={jobsAndGroupIds}
+        adJobsApiService={adJobsApiService}
+        onChange={useCallback(onAlertParamChange('includeJobs'), [])}
+        errors={Array.isArray(errors.includeJobs) ? errors.includeJobs : []}
+        multiSelect
+        label={
+          <FormattedMessage
+            id="xpack.ml.alertTypes.jobsHealthAlertingRule.includeJobs.label"
+            defaultMessage="Include jobs or groups"
+          />
+        }
+      />
+
+      <EuiSpacer size="m" />
+
+      <TestsSelectionControl
+        config={alertParams.testsConfig}
+        onChange={useCallback(onAlertParamChange('testsConfig'), [])}
+      />
+    </EuiForm>
+  );
+};
+
+// Default export is required for React.lazy loading
+
+// eslint-disable-next-line import/no-default-export
+export default AnomalyDetectionJobsHealthRuleTrigger;

x-pack/plugins/ml/public/alerting/jobs_health_rule/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
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+export { registerJobsHealthAlertingRule } from './register_jobs_health_alerting_rule';

x-pack/plugins/ml/public/alerting/jobs_health_rule/register_jobs_health_alerting_rule.ts

@@ -0,0 +1,57 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { lazy } from 'react';
+import { i18n } from '@kbn/i18n';
+import { TriggersAndActionsUIPublicPluginSetup } from '../../../../triggers_actions_ui/public';
+import { PluginSetupContract as AlertingSetup } from '../../../../alerting/public';
+import { ML_ALERT_TYPES } from '../../../common/constants/alerts';
+import { MlAnomalyDetectionJobsHealthRuleParams } from '../../../common/types/alerts';
+
+export function registerJobsHealthAlertingRule(
+  triggersActionsUi: TriggersAndActionsUIPublicPluginSetup,
+  alerting?: AlertingSetup
+) {
+  triggersActionsUi.alertTypeRegistry.register({
+    id: ML_ALERT_TYPES.AD_JOBS_HEALTH,
+    description: i18n.translate('xpack.ml.alertTypes.jobsHealthAlertingRule.description', {
+      defaultMessage: 'Alert when anomaly detection jobs experiencing realtime issues.',
+    }),
+    iconClass: 'bell',
+    documentationUrl(docLinks) {
+      return `${docLinks.ELASTIC_WEBSITE_URL}guide/en/machine-learning/${docLinks.DOC_LINK_VERSION}/ml-configuring-alerts.html`;
+    },
+    alertParamsExpression: lazy(() => import('./anomaly_detection_jobs_health_rule_trigger')),
+    validate: (alertParams: MlAnomalyDetectionJobsHealthRuleParams) => {
+      const validationResult = {
+        errors: {
+          includeJobs: new Array<string>(),
+        } as Record<keyof MlAnomalyDetectionJobsHealthRuleParams, string[]>,
+      };
+
+      if (!alertParams.includeJobs?.jobIds?.length && !alertParams.includeJobs?.groupIds?.length) {
+        validationResult.errors.includeJobs.push(
+          i18n.translate('xpack.ml.alertTypes.jobsHealthAlertingRule.includeJobs.errorMessage', {
+            defaultMessage: 'Job selection is required',
+          })
+        );
+      }
+
+      return validationResult;
+    },
+    requiresAppContext: false,
+    defaultActionMessage: i18n.translate(
+      'xpack.ml.alertTypes.jobsHealthAlertingRule.defaultActionMessage',
+      {
+        defaultMessage: `Anomaly detection jobs health check result:
+\\{\\{context.message\\}\\}
+- Job IDs: \\{\\{context.jobIds\\}\\}
+`,
+      }
+    ),
+  });
+}