[ML] Delayed data test for Anomaly Detection jobs health rule type

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

@@ -21,26 +21,57 @@ export const TOP_N_BUCKETS_COUNT = 1;
 
 export const ALL_JOBS_SELECTION = '*';
 
-export const HEALTH_CHECK_NAMES: Record<JobsHealthTests, string> = {
-  datafeed: i18n.translate('xpack.ml.alertTypes.jobsHealthAlertingRule.datafeedCheckName', {
-    defaultMessage: 'Datafeed is not started',
-  }),
-  mml: i18n.translate('xpack.ml.alertTypes.jobsHealthAlertingRule.mmlCheckName', {
-    defaultMessage: 'Model memory limit reached',
-  }),
-  errorMessages: i18n.translate(
-    'xpack.ml.alertTypes.jobsHealthAlertingRule.errorMessagesCheckName',
-    {
+export const HEALTH_CHECK_NAMES: Record<JobsHealthTests, { name: string; description: string }> = {
+  datafeed: {
+    name: i18n.translate('xpack.ml.alertTypes.jobsHealthAlertingRule.datafeedCheckName', {
+      defaultMessage: 'Datafeed is not started',
+    }),
+    description: i18n.translate(
+      'xpack.ml.alertTypes.jobsHealthAlertingRule.datafeedCheckDescription',
+      {
+        defaultMessage: 'Datafeed is not started',
+      }
+    ),
+  },
+  mml: {
+    name: i18n.translate('xpack.ml.alertTypes.jobsHealthAlertingRule.mmlCheckName', {
+      defaultMessage: 'Model memory limit reached',
+    }),
+    description: i18n.translate('xpack.ml.alertTypes.jobsHealthAlertingRule.mmlCheckDescription', {
+      defaultMessage: 'Get alerted when job reaches soft or hard model memory limit.',
+    }),
+  },
+  delayedData: {
+    name: i18n.translate('xpack.ml.alertTypes.jobsHealthAlertingRule.delayedDataCheckName', {
+      defaultMessage: 'Data delay has occurred',
+    }),
+    description: i18n.translate(
+      'xpack.ml.alertTypes.jobsHealthAlertingRule.delayedDataCheckDescription',
+      {
+        defaultMessage: 'Get alerted if a job has been identified as suffering from delayed data.',
+      }
+    ),
+  },
+  errorMessages: {
+    name: i18n.translate('xpack.ml.alertTypes.jobsHealthAlertingRule.errorMessagesCheckName', {
       defaultMessage: 'There are errors in the job messages',
-    }
-  ),
-  behindRealtime: i18n.translate(
-    'xpack.ml.alertTypes.jobsHealthAlertingRule.behindRealtimeCheckName',
-    {
+    }),
+    description: i18n.translate(
+      'xpack.ml.alertTypes.jobsHealthAlertingRule.errorMessagesCheckDescription',
+      {
+        defaultMessage: 'There are errors in the job messages',
+      }
+    ),
+  },
+  behindRealtime: {
+    name: i18n.translate('xpack.ml.alertTypes.jobsHealthAlertingRule.behindRealtimeCheckName', {
       defaultMessage: 'Job is running behind real-time',
-    }
-  ),
-  delayedData: i18n.translate('xpack.ml.alertTypes.jobsHealthAlertingRule.delayedDataCheckName', {
-    defaultMessage: 'Data delay has occurred',
-  }),
+    }),
+    description: i18n.translate(
+      'xpack.ml.alertTypes.jobsHealthAlertingRule.behindRealtimeCheckDescription',
+      {
+        defaultMessage: 'Job is running behind real-time',
+      }
+    ),
+  },
 };

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

@@ -109,7 +109,7 @@ export interface JobAlertingRuleStats {
   alerting_rules?: MlAnomalyDetectionAlertRule[];
 }
 
-interface CommonHealthCheckConfig {
+export interface CommonHealthCheckConfig {
   enabled: boolean;
 }
 

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

@@ -86,7 +86,12 @@ export interface Annotation {
   annotation: string;
   job_id: string;
   type: ANNOTATION_TYPE.ANNOTATION | ANNOTATION_TYPE.COMMENT;
-  event?: string;
+  event?:
+    | 'user'
+    | 'delayed_data'
+    | 'model_snapshot_stored'
+    | 'model_change'
+    | 'categorization_status_change';
   detector_index?: number;
   partition_field_name?: string;
   partition_field_value?: string;

x-pack/plugins/ml/common/util/alerts.test.ts

@@ -90,13 +90,22 @@ describe('getResultJobsHealthRuleConfig', () => {
       mml: {
         enabled: true,
       },
+      delayedData: {
+        docsCount: 0,
+        enabled: true,
+        timeInterval: null,
+      },
     });
   });
   test('returns config with overridden values based on provided configuration', () => {
     expect(
       getResultJobsHealthRuleConfig({
         mml: { enabled: false },
         errorMessages: { enabled: true },
+        delayedData: {
+          enabled: true,
+          docsCount: 1,
+        },
       })
     ).toEqual({
       datafeed: {
@@ -105,6 +114,11 @@ describe('getResultJobsHealthRuleConfig', () => {
       mml: {
         enabled: false,
       },
+      delayedData: {
+        docsCount: 1,
+        enabled: true,
+        timeInterval: null,
+      },
     });
   });
 });

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

@@ -54,7 +54,7 @@ export function getTopNBuckets(job: Job): number {
   return Math.ceil(narrowBucketLength / bucketSpan.asSeconds());
 }
 
-const implementedTests = ['datafeed', 'mml'] as JobsHealthTests[];
+const implementedTests = ['datafeed', 'mml', 'delayedData'] as JobsHealthTests[];
 
 /**
  * Returns tests configuration combined with default values.
@@ -70,6 +70,8 @@ export function getResultJobsHealthRuleConfig(config: JobsHealthRuleTestsConfig)
     },
     delayedData: {
       enabled: config?.delayedData?.enabled ?? true,
+      docsCount: config?.delayedData?.docsCount ?? 0,
+      timeInterval: config?.delayedData?.timeInterval ?? null,
     },
     behindRealtime: {
       enabled: config?.behindRealtime?.enabled ?? true,

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

@@ -12,6 +12,7 @@ import { PluginSetupContract as AlertingSetup } from '../../../../alerting/publi
 import { ML_ALERT_TYPES } from '../../../common/constants/alerts';
 import { MlAnomalyDetectionJobsHealthRuleParams } from '../../../common/types/alerts';
 import { getResultJobsHealthRuleConfig } from '../../../common/util/alerts';
+import { validateLookbackInterval } from '../validators';
 
 export function registerJobsHealthAlertingRule(
   triggersActionsUi: TriggersAndActionsUIPublicPluginSetup,
@@ -32,6 +33,7 @@ export function registerJobsHealthAlertingRule(
         errors: {
           includeJobs: new Array<string>(),
           testsConfig: new Array<string>(),
+          delayedData: new Array<string>(),
         } as Record<keyof MlAnomalyDetectionJobsHealthRuleParams, string[]>,
       };
 
@@ -53,6 +55,31 @@ export function registerJobsHealthAlertingRule(
         );
       }
 
+      if (
+        !!resultTestConfig.delayedData.timeInterval &&
+        validateLookbackInterval(resultTestConfig.delayedData.timeInterval)
+      ) {
+        validationResult.errors.delayedData.push(
+          i18n.translate(
+            'xpack.ml.alertTypes.jobsHealthAlertingRule.testsConfig.delayedData.timeIntervalErrorMessage',
+            {
+              defaultMessage: 'Time interval is invalid',
+            }
+          )
+        );
+      }
+
+      if (resultTestConfig.delayedData.docsCount === 0) {
+        validationResult.errors.delayedData.push(
+          i18n.translate(
+            'xpack.ml.alertTypes.jobsHealthAlertingRule.testsConfig.delayedData.docsCountErrorMessage',
+            {
+              defaultMessage: 'Number of documents is invalid',
+            }
+          )
+        );
+      }
+
       return validationResult;
     },
     requiresAppContext: false,

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

@@ -5,66 +5,121 @@
  * 2.0.
  */
 
-import React, { FC, Fragment, useCallback } from 'react';
-import { i18n } from '@kbn/i18n';
-import { EuiFormFieldset, EuiFormRow, EuiSpacer, EuiSwitch } from '@elastic/eui';
+import React, { FC, useCallback } from 'react';
+import {
+  EuiDescribedFormGroup,
+  EuiFieldNumber,
+  EuiForm,
+  EuiFormRow,
+  EuiSpacer,
+  EuiSwitch,
+} from '@elastic/eui';
+import { FormattedMessage } from '@kbn/i18n/react';
 import { JobsHealthRuleTestsConfig, JobsHealthTests } from '../../../common/types/alerts';
 import { getResultJobsHealthRuleConfig } from '../../../common/util/alerts';
 import { HEALTH_CHECK_NAMES } from '../../../common/constants/alerts';
+import { TimeIntervalControl } from '../time_interval_control';
 
 interface TestsSelectionControlProps {
   config: JobsHealthRuleTestsConfig;
   onChange: (update: JobsHealthRuleTestsConfig) => void;
   errors?: string[];
 }
 
-export const TestsSelectionControl: FC<TestsSelectionControlProps> = ({
-  config,
-  onChange,
-  errors,
-}) => {
-  const uiConfig = getResultJobsHealthRuleConfig(config);
+export const TestsSelectionControl: FC<TestsSelectionControlProps> = React.memo(
+  ({ config, onChange, errors }) => {
+    const uiConfig = getResultJobsHealthRuleConfig(config);
 
-  const updateCallback = useCallback(
-    (update: Partial<Exclude<JobsHealthRuleTestsConfig, undefined>>) => {
-      onChange({
-        ...(config ?? {}),
-        ...update,
-      });
-    },
-    [onChange, config]
-  );
+    const updateCallback = useCallback(
+      (update: Partial<Exclude<JobsHealthRuleTestsConfig, undefined>>) => {
+        onChange({
+          ...(config ?? {}),
+          ...update,
+        });
+      },
+      [onChange, config]
+    );
 
-  return (
-    <EuiFormFieldset
-      legend={{
-        children: i18n.translate(
-          'xpack.ml.alertTypes.jobsHealthAlertingRule.testsSelection.legend',
-          {
-            defaultMessage: 'Select health checks to perform',
-          }
-        ),
-      }}
-    >
-      {Object.entries(uiConfig).map(([name, conf], i) => {
-        return (
-          <Fragment key={name}>
-            <EuiFormRow
-              isInvalid={Object.keys(uiConfig).length === i + 1 && !!errors?.length}
-              error={errors}
+    return (
+      <EuiForm component="div" isInvalid={!!errors?.length} error={errors}>
+        {(Object.entries(uiConfig) as Array<
+          [JobsHealthTests, typeof uiConfig[JobsHealthTests]]
+        >).map(([name, conf], i) => {
+          return (
+            <EuiDescribedFormGroup
+              key={name}
+              title={<h4>{HEALTH_CHECK_NAMES[name]?.name}</h4>}
+              description={HEALTH_CHECK_NAMES[name]?.description}
             >
-              <EuiSwitch
-                label={HEALTH_CHECK_NAMES[name as JobsHealthTests]}
-                onChange={updateCallback.bind(null, {
-                  [name]: { enabled: !uiConfig[name as JobsHealthTests].enabled },
-                })}
-                checked={uiConfig[name as JobsHealthTests].enabled}
-              />
-            </EuiFormRow>
-            <EuiSpacer size="s" />
-          </Fragment>
-        );
-      })}
-    </EuiFormFieldset>
-  );
-};
+              <EuiFormRow>
+                <EuiSwitch
+                  label={
+                    <FormattedMessage
+                      id="xpack.ml.alertTypes.jobsHealthAlertingRule.testsSelection.enableTestLabel"
+                      defaultMessage="Enable"
+                    />
+                  }
+                  onChange={updateCallback.bind(null, {
+                    [name]: {
+                      ...uiConfig[name],
+                      enabled: !uiConfig[name].enabled,
+                    },
+                  })}
+                  checked={uiConfig[name].enabled}
+                />
+              </EuiFormRow>
+              <EuiSpacer size="s" />
+
+              {name === 'delayedData' ? (
+                <>
+                  <EuiFormRow
+                    label={
+                      <FormattedMessage
+                        id="xpack.ml.alertTypes.jobsHealthAlertingRule.testsSelection.delayedData.docsCountLabel"
+                        defaultMessage="Number of documents"
+                      />
+                    }
+                  >
+                    <EuiFieldNumber
+                      value={uiConfig.delayedData.docsCount}
+                      onChange={(e) => {
+                        updateCallback({
+                          [name]: {
+                            ...uiConfig[name],
+                            docsCount: Number(e.target.value),
+                          },
+                        });
+                      }}
+                    />
+                  </EuiFormRow>
+
+                  <EuiSpacer size="s" />
+
+                  <TimeIntervalControl
+                    label={
+                      <FormattedMessage
+                        id="xpack.ml.alertTypes.jobsHealthAlertingRule.testsSelection.delayedData.timeIntervalLabel"
+                        defaultMessage="Time interval"
+                      />
+                    }
+                    value={uiConfig.delayedData.timeInterval}
+                    onChange={(e) => {
+                      updateCallback({
+                        [name]: {
+                          ...uiConfig[name],
+                          timeInterval: e,
+                        },
+                      });
+                    }}
+                  />
+
+                  <EuiSpacer size="s" />
+                </>
+              ) : null}
+            </EuiDescribedFormGroup>
+          );
+        })}
+      </EuiForm>
+    );
+  }
+);