[RAM] Add data model for scheduled and recurring snoozes

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

@@ -21,6 +21,8 @@ export * from './disabled_action_groups';
 export * from './rule_notify_when_type';
 export * from './parse_duration';
 export * from './execution_log_types';
+export * from './rule_snooze_type';
+export * from './is_rule_snoozed';
 
 export interface AlertingFrameworkHealth {
   isSufficientlySecure: boolean;

x-pack/plugins/alerting/common/is_rule_snoozed.test.ts

@@ -0,0 +1,188 @@
+/*
+ * 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 moment from 'moment';
+import sinon from 'sinon';
+import { isRuleSnoozed } from './is_rule_snoozed';
+
+const LOCAL_OFFSET = moment('2020-01-01T00:00:00.000').format('Z');
+const DATE_9999 = '9999-12-31T12:34:56.789' + LOCAL_OFFSET;
+const DATE_1970 = '1970-01-01T00:00:00.000' + LOCAL_OFFSET;
+const DATE_1970_PLUS_6_HOURS = '1970-01-01T06:00:00.000' + LOCAL_OFFSET;
+const DATE_2020 = '2020-01-01T00:00:00.000' + LOCAL_OFFSET;
+const DATE_2020_MINUS_1_HOUR = '2019-12-31T23:00:00.000' + LOCAL_OFFSET;
+const DATE_2020_MINUS_1_MONTH = '2019-12-01T00:00:00.000' + LOCAL_OFFSET;
+
+const NOW = DATE_2020;
+
+let fakeTimer: sinon.SinonFakeTimers;
+
+describe('isRuleSnoozed', () => {
+  beforeAll(() => {
+    fakeTimer = sinon.useFakeTimers(new Date(NOW));
+  });
+
+  afterAll(() => fakeTimer.restore());
+
+  test('returns false when snooze has not yet started', () => {
+    const snoozeSchedule = [
+      {
+        startTime: DATE_9999,
+        duration: 100000000,
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule })).toBe(false);
+  });
+
+  test('returns true when snooze has started', () => {
+    const snoozeSchedule = [
+      {
+        startTime: NOW,
+        duration: 100000000,
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule })).toBe(true);
+  });
+
+  test('returns false when snooze has ended', () => {
+    const snoozeSchedule = [
+      {
+        startTime: DATE_1970,
+        duration: 100000000,
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule })).toBe(false);
+  });
+
+  test('returns true when snooze is indefinite', () => {
+    const snoozeSchedule = [
+      {
+        startTime: DATE_9999,
+        duration: 100000000,
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule, snoozeIndefinitely: true })).toBe(true);
+  });
+
+  test('returns as expected for an indefinitely recurring snooze', () => {
+    const snoozeScheduleA = [
+      {
+        startTime: DATE_1970,
+        duration: 60 * 1000,
+        repeatInterval: '1d',
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleA })).toBe(true);
+    const snoozeScheduleB = [
+      {
+        startTime: DATE_1970_PLUS_6_HOURS,
+        duration: 60 * 1000,
+        repeatInterval: '1d',
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleB })).toBe(false);
+    const snoozeScheduleC = [
+      {
+        startTime: DATE_2020_MINUS_1_HOUR,
+        duration: 60 * 1000,
+        repeatInterval: '1h',
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleC })).toBe(true);
+  });
+
+  test('returns as expected for a recurring snooze with limited occurrences', () => {
+    const snoozeScheduleA = [
+      {
+        startTime: DATE_1970,
+        duration: 60 * 1000,
+        repeatInterval: '1h',
+        occurrences: 600000,
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleA })).toBe(true);
+    const snoozeScheduleB = [
+      {
+        startTime: DATE_1970,
+        duration: 60 * 1000,
+        repeatInterval: '1h',
+        occurrences: 25,
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleB })).toBe(false);
+
+    // FIXME: THIS FAILS due to not compensating for leap years. Also 1M intervals exhibit confusing behavior
+    // Either we should add something to compensate for this, or disable the use of M and y, and only allow for explicit day lengths
+    //   const snoozeScheduleC = [
+    //     {
+    //       startTime: DATE_1970,
+    //       duration: 60 * 1000,
+    //       repeatInterval: '1y',
+    //       occurrences: 60,
+    //     },
+    //   ];
+    //   expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleC })).toBe(true);
+  });
+
+  test('returns as expected for a recurring snooze with an end date', () => {
+    const snoozeScheduleA = [
+      {
+        startTime: DATE_1970,
+        duration: 60 * 1000,
+        repeatInterval: '1h',
+        repeatEndTime: DATE_9999,
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleA })).toBe(true);
+    const snoozeScheduleB = [
+      {
+        startTime: DATE_1970,
+        duration: 60 * 1000,
+        repeatInterval: '1h',
+        repeatEndTime: DATE_2020_MINUS_1_HOUR,
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleB })).toBe(false);
+  });
+
+  test('returns as expected for a recurring snooze on a day of the week', () => {
+    const snoozeScheduleA = [
+      {
+        startTime: DATE_1970,
+        duration: 60 * 1000,
+        repeatInterval: 'DOW:135', // Monday Wednesday Friday; Jan 1 2020 was a Wednesday
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleA })).toBe(true);
+    const snoozeScheduleB = [
+      {
+        startTime: DATE_1970,
+        duration: 60 * 1000,
+        repeatInterval: 'DOW:2467', // Tue, Thu, Sat, Sun
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleB })).toBe(false);
+    const snoozeScheduleC = [
+      {
+        startTime: DATE_2020_MINUS_1_MONTH,
+        duration: 60 * 1000,
+        repeatInterval: 'DOW:135',
+        occurrences: 12,
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleC })).toBe(false);
+    const snoozeScheduleD = [
+      {
+        startTime: DATE_2020_MINUS_1_MONTH,
+        duration: 60 * 1000,
+        repeatInterval: 'DOW:135',
+        occurrences: 15,
+      },
+    ];
+    expect(isRuleSnoozed({ snoozeSchedule: snoozeScheduleD })).toBe(true);
+  });
+});

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

@@ -0,0 +1,81 @@
+/*
+ * 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 moment from 'moment';
+import { parseInterval } from '@kbn/data-plugin/common';
+import { SanitizedRule, RuleTypeParams } from './rule';
+
+type RuleSnoozeProps = Pick<SanitizedRule<RuleTypeParams>, 'snoozeIndefinitely' | 'snoozeSchedule'>;
+
+export function getRuleSnoozeEndTime(rule: RuleSnoozeProps): Date | null {
+  if (rule.snoozeSchedule == null) {
+    return null;
+  }
+
+  const now = Date.now();
+  for (const snooze of rule.snoozeSchedule) {
+    const { startTime, duration, repeatInterval, occurrences, repeatEndTime } = snooze;
+    const startTimeMS = Date.parse(startTime);
+    const initialEndTime = startTimeMS + duration;
+    // If now is during the first occurrence of the snooze
+
+    if (now >= startTimeMS && now < initialEndTime) return new Date(initialEndTime);
+
+    // Check to see if now is during a recurrence of the snooze
+    if (repeatInterval) {
+      let occurrence;
+      let occurrenceStartTime;
+      if (repeatEndTime) {
+        const repeatEndTimeMS = Date.parse(repeatEndTime);
+        if (now >= repeatEndTimeMS) continue;
+      }
+      const timeFromInitialStart = now - startTimeMS;
+
+      // Handle day-of-week recurrences
+      if (repeatInterval.startsWith('DOW:')) {
+        const [, daysOfWeekString] = repeatInterval.split(':');
+        const repeatDays = daysOfWeekString
+          .split('')
+          .map((d) => Number(d))
+          .sort();
+        const today = moment(now).isoWeekday();
+
+        if (!repeatDays.includes(today)) continue;
+
+        const weeksFromInitialStart = moment(now).diff(moment(startTime), 'weeks');
+        const occurrencesPerWeek = repeatDays.length;
+        occurrence = weeksFromInitialStart * occurrencesPerWeek + repeatDays.indexOf(today);
+        const nowMoment = moment(now);
+        occurrenceStartTime = moment(startTime)
+          .year(nowMoment.year())
+          .dayOfYear(nowMoment.dayOfYear())
+          .valueOf();
+      } else {
+        const interval = parseInterval(repeatInterval)?.asMilliseconds();
+        if (!interval) continue;
+
+        occurrence = Math.floor(timeFromInitialStart / interval);
+        occurrenceStartTime = interval * occurrence + startTimeMS;
+      }
+
+      if (occurrences && occurrence > occurrences) continue;
+
+      const occurrenceEndTime = occurrenceStartTime + duration;
+
+      if (now >= occurrenceStartTime && now < occurrenceEndTime) return new Date(occurrenceEndTime);
+    }
+  }
+
+  return null;
+}
+
+export function isRuleSnoozed(rule: RuleSnoozeProps) {
+  if (rule.snoozeIndefinitely) {
+    return true;
+  }
+  return Boolean(getRuleSnoozeEndTime(rule));
+}

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

@@ -12,6 +12,7 @@ import {
   // eslint-disable-next-line @kbn/eslint/no-restricted-paths
 } from '@kbn/core/server';
 import { RuleNotifyWhenType } from './rule_notify_when_type';
+import { RuleSnooze } from './rule_snooze_type';
 
 export type RuleTypeState = Record<string, unknown>;
 export type RuleTypeParams = Record<string, unknown>;
@@ -104,11 +105,11 @@ export interface Rule<Params extends RuleTypeParams = never> {
   apiKeyOwner: string | null;
   throttle: string | null;
   notifyWhen: RuleNotifyWhenType | null;
-  muteAll: boolean;
   mutedInstanceIds: string[];
   executionStatus: RuleExecutionStatus;
   monitoring?: RuleMonitoring;
-  snoozeEndTime?: Date | null; // Remove ? when this parameter is made available in the public API
+  snoozeIndefinitely?: boolean;
+  snoozeSchedule?: RuleSnooze; // Remove ? when this parameter is made available in the public API
 }
 
 export type SanitizedRule<Params extends RuleTypeParams = never> = Omit<Rule<Params>, 'apiKey'>;

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

@@ -0,0 +1,15 @@
+/*
+ * 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 type RuleSnooze = Array<{
+  startTime: string;
+  duration: number;
+  id?: string;
+  repeatInterval?: string;
+  occurrences?: number;
+  repeatEndTime?: string;
+}>;

x-pack/plugins/alerting/server/routes/find_rules.ts

@@ -79,12 +79,12 @@ const rewriteBodyRes: RewriteResponseCase<FindResult<RuleTypeParams>> = ({
         updatedAt,
         apiKeyOwner,
         notifyWhen,
-        muteAll,
         mutedInstanceIds,
         executionStatus,
         actions,
         scheduledTaskId,
-        snoozeEndTime,
+        snoozeIndefinitely,
+        snoozeSchedule,
         ...rest
       }) => ({
         ...rest,
@@ -95,11 +95,11 @@ const rewriteBodyRes: RewriteResponseCase<FindResult<RuleTypeParams>> = ({
         updated_at: updatedAt,
         api_key_owner: apiKeyOwner,
         notify_when: notifyWhen,
-        mute_all: muteAll,
         muted_alert_ids: mutedInstanceIds,
         scheduled_task_id: scheduledTaskId,
-        // Remove this object spread boolean check after snoozeEndTime is added to the public API
-        ...(snoozeEndTime !== undefined ? { snooze_end_time: snoozeEndTime } : {}),
+        // Remove these object spread boolean check after snooze props is added to the public API
+        ...(snoozeIndefinitely !== undefined ? { snooze_indefinitely: snoozeIndefinitely } : {}),
+        ...(snoozeSchedule !== undefined ? { snooze_schedule: snoozeSchedule } : {}),
         execution_status: executionStatus && {
           ...omit(executionStatus, 'lastExecutionDate', 'lastDuration'),
           last_execution_date: executionStatus.lastExecutionDate,

x-pack/plugins/alerting/server/routes/get_rule.ts

@@ -30,12 +30,12 @@ const rewriteBodyRes: RewriteResponseCase<SanitizedRule<RuleTypeParams>> = ({
   updatedAt,
   apiKeyOwner,
   notifyWhen,
-  muteAll,
   mutedInstanceIds,
   executionStatus,
   actions,
   scheduledTaskId,
-  snoozeEndTime,
+  snoozeIndefinitely,
+  snoozeSchedule,
   ...rest
 }) => ({
   ...rest,
@@ -46,10 +46,10 @@ const rewriteBodyRes: RewriteResponseCase<SanitizedRule<RuleTypeParams>> = ({
   updated_at: updatedAt,
   api_key_owner: apiKeyOwner,
   notify_when: notifyWhen,
-  mute_all: muteAll,
   muted_alert_ids: mutedInstanceIds,
-  // Remove this object spread boolean check after snoozeEndTime is added to the public API
-  ...(snoozeEndTime !== undefined ? { snooze_end_time: snoozeEndTime } : {}),
+  // Remove these object spread boolean check after snooze props is added to the public API
+  ...(snoozeIndefinitely !== undefined ? { snooze_indefinitely: snoozeIndefinitely } : {}),
+  ...(snoozeSchedule !== undefined ? { snooze_schedule: snoozeSchedule } : {}),
   scheduled_task_id: scheduledTaskId,
   execution_status: executionStatus && {
     ...omit(executionStatus, 'lastExecutionDate', 'lastDuration'),