[RAM] Update rule status

src/core/server/integration_tests/saved_objects/migrations/check_registered_types.test.ts

@@ -53,7 +53,7 @@ describe('checking migration metadata changes on all registered SO types', () =>
       Object {
         "action": "7858e6d5a9f231bf23f6f2e57328eb0095b26735",
         "action_task_params": "bbd38cbfd74bf6713586fe078e3fa92db2234299",
-        "alert": "48461f3375d9ba22882ea23a318b62a5b0921a9b",
+        "alert": "eefada4a02ce05962387c0679d7b292771a931c4",
         "api_key_pending_invalidation": "9b4bc1235337da9a87ef05a1d1f4858b2a3b77c6",
         "apm-indices": "ceb0870f3a74e2ffc3a1cd3a3c73af76baca0999",
         "apm-server-schema": "2bfd2998d3873872e1366458ce553def85418f91",

x-pack/plugins/alerting/common/rule.ts

@@ -32,6 +32,9 @@ export const RuleExecutionStatusValues = [
 ] as const;
 export type RuleExecutionStatuses = typeof RuleExecutionStatusValues[number];
 
+export const RuleLastRunOutcomeValues = ['succeeded', 'warning', 'failed'] as const;
+export type RuleLastRunOutcomes = typeof RuleLastRunOutcomeValues[number];
+
 export enum RuleExecutionStatusErrorReasons {
   Read = 'read',
   Decrypt = 'decrypt',
@@ -76,12 +79,25 @@ export interface RuleAction {
 
 export interface RuleAggregations {
   alertExecutionStatus: { [status: string]: number };
+  ruleLastRunOutcome: { [status: string]: number };
   ruleEnabledStatus: { enabled: number; disabled: number };
   ruleMutedStatus: { muted: number; unmuted: number };
   ruleSnoozedStatus: { snoozed: number };
   ruleTags: string[];
 }
 
+export interface RuleLastRun {
+  outcome: RuleLastRunOutcomes;
+  warning?: RuleExecutionStatusErrorReasons | RuleExecutionStatusWarningReasons | null;
+  outcomeMsg?: string | null;
+  alertsCount: {
+    active?: number | null;
+    new?: number | null;
+    recovered?: number | null;
+    ignored?: number | null;
+  };
+}
+
 export interface MappedParamsProperties {
   risk_score?: number;
   severity?: string;
@@ -116,6 +132,8 @@ export interface Rule<Params extends RuleTypeParams = never> {
   snoozeSchedule?: RuleSnooze; // Remove ? when this parameter is made available in the public API
   activeSnoozes?: string[];
   isSnoozedUntil?: Date | null;
+  lastRun?: RuleLastRun | null;
+  nextRun?: Date | null;
 }
 
 export type SanitizedRule<Params extends RuleTypeParams = never> = Omit<Rule<Params>, 'apiKey'>;
@@ -175,16 +193,34 @@ export interface RuleMonitoringHistory extends SavedObjectAttributes {
   success: boolean;
   timestamp: number;
   duration?: number;
+  outcome?: RuleLastRunOutcomes;
+}
+
+export interface RuleMonitoringCalculatedMetrics extends SavedObjectAttributes {
+  p50?: number;
+  p95?: number;
+  p99?: number;
+  success_ratio: number;
+}
+
+export interface RuleMonitoringLastRunMetrics extends SavedObjectAttributes {
+  duration?: number;
+  total_search_duration_ms?: number | null;
+  total_indexing_duration_ms?: number | null;
+  total_alerts_detected?: number | null;
+  total_alerts_created?: number | null;
+  gap_duration_s?: number | null;
+}
+
+export interface RuleMonitoringLastRun extends SavedObjectAttributes {
+  timestamp: string;
+  metrics: RuleMonitoringLastRunMetrics;
 }
 
-export interface RuleMonitoring extends SavedObjectAttributes {
-  execution: {
+export interface RuleMonitoring {
+  run: {
     history: RuleMonitoringHistory[];
-    calculated_metrics: {
-      p50?: number;
-      p95?: number;
-      p99?: number;
-      success_ratio: number;
-    };
+    calculated_metrics: RuleMonitoringCalculatedMetrics;
+    last_run: RuleMonitoringLastRun;
   };
 }

x-pack/plugins/alerting/public/lib/common_transformations.test.ts

@@ -6,7 +6,7 @@
  */
 
 import { ApiRule, transformRule } from './common_transformations';
-import { RuleExecutionStatusErrorReasons } from '../../common';
+import { RuleExecutionStatusErrorReasons, RuleLastRunOutcomeValues } from '../../common';
 
 beforeEach(() => jest.resetAllMocks());
 
@@ -54,6 +54,43 @@ describe('common_transformations', () => {
           message: 'this is just a test',
         },
       },
+      monitoring: {
+        run: {
+          history: [
+            {
+              timestamp: dateExecuted.getTime(),
+              duration: 42,
+              success: false,
+              outcome: RuleLastRunOutcomeValues[2],
+            },
+          ],
+          calculated_metrics: {
+            success_ratio: 0,
+            p50: 0,
+            p95: 42,
+            p99: 42,
+          },
+          last_run: {
+            timestamp: dateExecuted.toISOString(),
+            metrics: {
+              duration: 42,
+              total_search_duration_ms: 100,
+            },
+          },
+        },
+      },
+      last_run: {
+        outcome: RuleLastRunOutcomeValues[2],
+        outcome_msg: 'this is just a test',
+        warning: RuleExecutionStatusErrorReasons.Unknown,
+        alerts_count: {
+          new: 1,
+          active: 2,
+          recovered: 3,
+          ignored: 4,
+        },
+      },
+      next_run: dateUpdated.toISOString(),
     };
     expect(transformRule(apiRule)).toMatchInlineSnapshot(`
       Object {
@@ -89,12 +126,49 @@ describe('common_transformations', () => {
           "status": "error",
         },
         "id": "some-id",
+        "lastRun": Object {
+          "alertsCount": Object {
+            "active": 2,
+            "ignored": 4,
+            "new": 1,
+            "recovered": 3,
+          },
+          "outcome": "failed",
+          "outcomeMsg": "this is just a test",
+          "warning": "unknown",
+        },
+        "monitoring": Object {
+          "run": Object {
+            "calculated_metrics": Object {
+              "p50": 0,
+              "p95": 42,
+              "p99": 42,
+              "success_ratio": 0,
+            },
+            "history": Array [
+              Object {
+                "duration": 42,
+                "outcome": "failed",
+                "success": false,
+                "timestamp": 1639571696789,
+              },
+            ],
+            "last_run": Object {
+              "metrics": Object {
+                "duration": 42,
+                "total_search_duration_ms": 100,
+              },
+              "timestamp": "2021-12-15T12:34:56.789Z",
+            },
+          },
+        },
         "muteAll": false,
         "mutedInstanceIds": Array [
           "bob",
           "jim",
         ],
         "name": "some-name",
+        "nextRun": 2021-12-15T12:34:55.789Z,
         "notifyWhen": "onActiveAlert",
         "params": Object {
           "bar": "foo",
@@ -152,6 +226,43 @@ describe('common_transformations', () => {
         last_execution_date: dateExecuted.toISOString(),
         status: 'error',
       },
+      monitoring: {
+        run: {
+          history: [
+            {
+              timestamp: dateExecuted.getTime(),
+              duration: 42,
+              success: false,
+              outcome: 'failed',
+            },
+          ],
+          calculated_metrics: {
+            success_ratio: 0,
+            p50: 0,
+            p95: 42,
+            p99: 42,
+          },
+          last_run: {
+            timestamp: dateExecuted.toISOString(),
+            metrics: {
+              duration: 42,
+              total_search_duration_ms: 100,
+            },
+          },
+        },
+      },
+      last_run: {
+        outcome: 'failed',
+        outcome_msg: 'this is just a test',
+        warning: RuleExecutionStatusErrorReasons.Unknown,
+        alerts_count: {
+          new: 1,
+          active: 2,
+          recovered: 3,
+          ignored: 4,
+        },
+      },
+      next_run: dateUpdated.toISOString(),
     };
     expect(transformRule(apiRule)).toMatchInlineSnapshot(`
       Object {
@@ -176,12 +287,49 @@ describe('common_transformations', () => {
           "status": "error",
         },
         "id": "some-id",
+        "lastRun": Object {
+          "alertsCount": Object {
+            "active": 2,
+            "ignored": 4,
+            "new": 1,
+            "recovered": 3,
+          },
+          "outcome": "failed",
+          "outcomeMsg": "this is just a test",
+          "warning": "unknown",
+        },
+        "monitoring": Object {
+          "run": Object {
+            "calculated_metrics": Object {
+              "p50": 0,
+              "p95": 42,
+              "p99": 42,
+              "success_ratio": 0,
+            },
+            "history": Array [
+              Object {
+                "duration": 42,
+                "outcome": "failed",
+                "success": false,
+                "timestamp": 1639571696789,
+              },
+            ],
+            "last_run": Object {
+              "metrics": Object {
+                "duration": 42,
+                "total_search_duration_ms": 100,
+              },
+              "timestamp": "2021-12-15T12:34:56.789Z",
+            },
+          },
+        },
         "muteAll": false,
         "mutedInstanceIds": Array [
           "bob",
           "jim",
         ],
         "name": "some-name",
+        "nextRun": 2021-12-15T12:34:55.789Z,
         "notifyWhen": "onActiveAlert",
         "params": Object {},
         "schedule": Object {

x-pack/plugins/alerting/public/lib/common_transformations.ts

@@ -5,7 +5,14 @@
  * 2.0.
  */
 import { AsApiContract } from '@kbn/actions-plugin/common';
-import { RuleExecutionStatus, Rule, RuleAction, RuleType } from '../../common';
+import {
+  RuleExecutionStatus,
+  RuleMonitoring,
+  Rule,
+  RuleLastRun,
+  RuleAction,
+  RuleType,
+} from '../../common';
 
 function transformAction(input: AsApiContract<RuleAction>): RuleAction {
   const { connector_type_id: actionTypeId, ...rest } = input;
@@ -27,6 +34,31 @@ function transformExecutionStatus(input: ApiRuleExecutionStatus): RuleExecutionS
   };
 }
 
+function transformMonitoring(input: RuleMonitoring): RuleMonitoring {
+  const { run } = input;
+  const { last_run: lastRun, ...rest } = run;
+  const { timestamp, ...restLastRun } = lastRun;
+
+  return {
+    run: {
+      last_run: {
+        timestamp: input.run.last_run.timestamp,
+        ...restLastRun,
+      },
+      ...rest,
+    },
+  };
+}
+
+function transformLastRun(input: AsApiContract<RuleLastRun>): RuleLastRun {
+  const { outcome_msg: outcomeMsg, alerts_count: alertsCount, ...rest } = input;
+  return {
+    outcomeMsg,
+    alertsCount,
+    ...rest,
+  };
+}
+
 // AsApiContract does not deal with object properties that also
 // need snake -> camel conversion, Dates, are renamed, etc, so we do by hand
 export type ApiRule = Omit<
@@ -37,13 +69,17 @@ export type ApiRule = Omit<
   | 'updated_at'
   | 'alert_type_id'
   | 'muted_instance_ids'
+  | 'last_run'
+  | 'next_run'
 > & {
   execution_status: ApiRuleExecutionStatus;
   actions: Array<AsApiContract<RuleAction>>;
   created_at: string;
   updated_at: string;
   rule_type_id: string;
   muted_alert_ids: string[];
+  last_run?: AsApiContract<RuleLastRun>;
+  next_run?: string;
 };
 
 export function transformRule(input: ApiRule): Rule {
@@ -61,6 +97,9 @@ export function transformRule(input: ApiRule): Rule {
     scheduled_task_id: scheduledTaskId,
     execution_status: executionStatusAPI,
     actions: actionsAPI,
+    next_run: nextRun,
+    last_run: lastRun,
+    monitoring: monitoring,
     ...rest
   } = input;
 
@@ -78,6 +117,9 @@ export function transformRule(input: ApiRule): Rule {
     executionStatus: transformExecutionStatus(executionStatusAPI),
     actions: actionsAPI ? actionsAPI.map((action) => transformAction(action)) : [],
     scheduledTaskId,
+    ...(nextRun ? { nextRun: new Date(nextRun) } : {}),
+    ...(monitoring ? { monitoring: transformMonitoring(monitoring) } : {}),
+    ...(lastRun ? { lastRun: transformLastRun(lastRun) } : {}),
     ...rest,
   };
 }

x-pack/plugins/alerting/server/lib/index.ts

@@ -25,6 +25,13 @@ export {
   ruleExecutionStatusToRaw,
   ruleExecutionStatusFromRaw,
 } from './rule_execution_status';
+export { lastRunFromState, lastRunFromError, lastRunToRaw } from './last_run_status';
+export {
+  updateMonitoring,
+  getDefaultMonitoring,
+  convertMonitoringFromRawAndVerify,
+} from './monitoring';
+export { getNextRun } from './next_run';
 export { processAlerts } from './process_alerts';
 export { createWrappedScopedClusterClientFactory } from './wrap_scoped_cluster_client';
 export { isRuleSnoozed, getRuleSnoozeEndTime } from './is_rule_snoozed';