Gap auto fill scheduler UI and API

x-pack/platform/plugins/shared/alerting/common/constants/gap_auto_fill_scheduler.ts

@@ -28,3 +28,12 @@ export const gapAutoFillSchedulerLimits = {
   },
   minScheduleIntervalInMs: 60 * 1000,
 } as const;
+
+export const GAP_AUTO_FILL_STATUS = {
+  SUCCESS: 'success',
+  ERROR: 'error',
+  SKIPPED: 'skipped',
+  NO_GAPS: 'no_gaps',
+} as const;
+
+export type GapAutoFillStatus = (typeof GAP_AUTO_FILL_STATUS)[keyof typeof GAP_AUTO_FILL_STATUS];

x-pack/platform/plugins/shared/alerting/common/constants/index.ts

@@ -19,3 +19,5 @@ export { alertDeleteCategoryIds } from './alert_delete';
 export type { BackfillInitiator } from './backfill';
 export { backfillInitiator } from './backfill';
 export { gapAutoFillSchedulerLimits } from './gap_auto_fill_scheduler';
+export { GAP_AUTO_FILL_STATUS } from './gap_auto_fill_scheduler';
+export type { GapAutoFillStatus } from './gap_auto_fill_scheduler';

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

@@ -180,7 +180,8 @@ export {
   systemConnectorActionRefPrefix,
 } from './action_ref_prefix';
 export { gapStatus } from './constants';
-
+export { GAP_AUTO_FILL_STATUS } from './constants';
+export type { GapAutoFillStatus } from './constants';
 export {
   mappingFromFieldMap,
   getComponentTemplateFromFieldMap,

x-pack/platform/plugins/shared/alerting/common/routes/gaps/apis/gap_auto_fill_scheduler/index.ts

@@ -7,22 +7,44 @@
 
 export {
   gapAutoFillSchedulerBodySchema,
+  gapAutoFillSchedulerUpdateBodySchema,
   gapAutoFillSchedulerResponseSchema,
+  getGapAutoFillSchedulerParamsSchema,
+  gapAutoFillSchedulerLogEntrySchema,
+  gapAutoFillSchedulerLogsResponseSchema,
+  gapAutoFillSchedulerLogsRequestQuerySchema,
 } from './schemas/latest';
 export type {
   GapAutoFillSchedulerRequestBody,
   GapAutoFillSchedulerResponseBody,
   GapAutoFillSchedulerResponse,
+  UpdateGapAutoFillSchedulerRequestBody,
   UpdateGapAutoFillSchedulerResponse,
+  GetGapAutoFillSchedulerParams,
+  GapAutoFillSchedulerLogEntry,
+  GapAutoFillSchedulerLogsResponseBody,
+  GapAutoFillSchedulerLogsResponse,
+  GapAutoFillSchedulerLogsRequestQuery,
 } from './types/latest';
 
 export {
   gapAutoFillSchedulerBodySchema as gapAutoFillSchedulerBodySchemaV1,
+  gapAutoFillSchedulerUpdateBodySchema as gapAutoFillSchedulerUpdateBodySchemaV1,
   gapAutoFillSchedulerResponseSchema as gapAutoFillSchedulerResponseSchemaV1,
+  getGapAutoFillSchedulerParamsSchema as getGapAutoFillSchedulerParamsSchemaV1,
+  gapAutoFillSchedulerLogEntrySchema as gapAutoFillSchedulerLogEntrySchemaV1,
+  gapAutoFillSchedulerLogsResponseSchema as gapAutoFillSchedulerLogsResponseSchemaV1,
+  gapAutoFillSchedulerLogsRequestQuerySchema as gapAutoFillSchedulerLogsRequestQuerySchemaV1,
 } from './schemas/v1';
 export type {
   GapAutoFillSchedulerRequestBody as GapAutoFillSchedulerRequestBodyV1,
   GapAutoFillSchedulerResponseBody as GapAutoFillSchedulerResponseBodyV1,
   GapAutoFillSchedulerResponse as GapAutoFillSchedulerResponseV1,
+  UpdateGapAutoFillSchedulerRequestBody as UpdateGapAutoFillSchedulerRequestBodyV1,
   UpdateGapAutoFillSchedulerResponse as UpdateGapAutoFillSchedulerResponseV1,
+  GetGapAutoFillSchedulerParams as GetGapAutoFillSchedulerParamsV1,
+  GapAutoFillSchedulerLogEntry as GapAutoFillSchedulerLogEntryV1,
+  GapAutoFillSchedulerLogsResponseBody as GapAutoFillSchedulerLogsResponseBodyV1,
+  GapAutoFillSchedulerLogsResponse as GapAutoFillSchedulerLogsResponseV1,
+  GapAutoFillSchedulerLogsRequestQuery as GapAutoFillSchedulerLogsRequestQueryV1,
 } from './types/v1';

x-pack/platform/plugins/shared/alerting/common/routes/gaps/apis/gap_auto_fill_scheduler/schemas/v1.ts

@@ -14,6 +14,51 @@ import { parseDuration } from '../../../../../parse_duration';
 
 const { maxBackfills, numRetries, minScheduleIntervalInMs } = gapAutoFillSchedulerLimits;
 
+const validateGapAutoFillSchedulerPayload = (
+  gapFillRange: string,
+  schedule: { interval: string },
+  ruleTypes: { type: string; consumer: string }[]
+) => {
+  const now = new Date();
+  const parsed = dateMath.parse(gapFillRange, { forceNow: now });
+  if (!parsed || !parsed.isValid()) {
+    return 'gap_fill_range is invalid';
+  }
+
+  const maxLookbackExpression = `now-${MAX_SCHEDULE_BACKFILL_LOOKBACK_WINDOW_DAYS}d`;
+  const lookbackLimit = dateMath.parse(maxLookbackExpression, { forceNow: now });
+  if (!lookbackLimit || !lookbackLimit.isValid()) {
+    return 'gap_fill_range is invalid';
+  }
+
+  if (parsed.isBefore(lookbackLimit)) {
+    return `gap_fill_range cannot look back more than ${MAX_SCHEDULE_BACKFILL_LOOKBACK_WINDOW_DAYS} days`;
+  }
+
+  try {
+    const intervalMs = parseDuration(schedule.interval);
+    if (intervalMs < minScheduleIntervalInMs) {
+      return 'schedule.interval must be at least 1 minute';
+    }
+  } catch (error) {
+    return `schedule.interval is invalid: ${(error as Error).message}`;
+  }
+
+  // Duplicate check for rule_types
+  const seen = new Set<string>();
+  for (const ruleType of ruleTypes) {
+    const key = `${ruleType.type}:${ruleType.consumer}`;
+    if (seen.has(key)) {
+      return `rule_types contains duplicate entry: type="${ruleType.type}" consumer="${ruleType.consumer}"`;
+    }
+    seen.add(key);
+  }
+};
+
+export const getGapAutoFillSchedulerParamsSchema = schema.object({
+  id: schema.string(),
+});
+
 export const gapAutoFillSchedulerBodySchema = schema.object(
   {
     id: schema.maybe(schema.string()),
@@ -34,41 +79,41 @@ export const gapAutoFillSchedulerBodySchema = schema.object(
     ),
   },
   {
-    validate({ gap_fill_range: gapFillRange, schedule, rule_types: ruleTypes }) {
-      const now = new Date();
-      const parsed = dateMath.parse(gapFillRange, { forceNow: now });
-      if (!parsed || !parsed.isValid()) {
-        return 'gap_fill_range is invalid';
-      }
-
-      const maxLookbackExpression = `now-${MAX_SCHEDULE_BACKFILL_LOOKBACK_WINDOW_DAYS}d`;
-      const lookbackLimit = dateMath.parse(maxLookbackExpression, { forceNow: now });
-      if (!lookbackLimit || !lookbackLimit.isValid()) {
-        return 'gap_fill_range is invalid';
-      }
-
-      if (parsed.isBefore(lookbackLimit)) {
-        return `gap_fill_range cannot look back more than ${MAX_SCHEDULE_BACKFILL_LOOKBACK_WINDOW_DAYS} days`;
-      }
-
-      try {
-        const intervalMs = parseDuration(schedule.interval);
-        if (intervalMs < minScheduleIntervalInMs) {
-          return 'schedule.interval must be at least 1 minute';
-        }
-      } catch (error) {
-        return `schedule.interval is invalid: ${(error as Error).message}`;
-      }
+    validate(payload) {
+      return validateGapAutoFillSchedulerPayload(
+        payload.gap_fill_range,
+        payload.schedule,
+        payload.rule_types
+      );
+    },
+  }
+);
 
-      // Duplicate check for rule_types
-      const seen = new Set<string>();
-      for (const ruleType of ruleTypes) {
-        const key = `${ruleType.type}:${ruleType.consumer}`;
-        if (seen.has(key)) {
-          return `rule_types contains duplicate entry: type="${ruleType.type}" consumer="${ruleType.consumer}"`;
-        }
-        seen.add(key);
-      }
+export const gapAutoFillSchedulerUpdateBodySchema = schema.object(
+  {
+    name: schema.string(),
+    enabled: schema.boolean(),
+    gap_fill_range: schema.string(),
+    max_backfills: schema.number({ min: 1, max: 5000 }),
+    num_retries: schema.number({ min: 1 }),
+    schedule: schema.object({
+      interval: schema.string(),
+    }),
+    scope: schema.arrayOf(schema.string()),
+    rule_types: schema.arrayOf(
+      schema.object({
+        type: schema.string(),
+        consumer: schema.string(),
+      })
+    ),
+  },
+  {
+    validate(payload) {
+      return validateGapAutoFillSchedulerPayload(
+        payload.gap_fill_range,
+        payload.schedule,
+        payload.rule_types
+      );
     },
   }
 );
@@ -95,3 +140,48 @@ export const gapAutoFillSchedulerResponseSchema = schema.object({
   created_at: schema.string(),
   updated_at: schema.string(),
 });
+
+export const gapAutoFillSchedulerLogsRequestQuerySchema = schema.object({
+  start: schema.string(),
+  end: schema.string(),
+  page: schema.number({ defaultValue: 1, min: 1 }),
+  per_page: schema.number({ defaultValue: 50, min: 1, max: 1000 }),
+  sort_field: schema.oneOf([schema.literal('@timestamp')], { defaultValue: '@timestamp' }),
+  sort_direction: schema.oneOf([schema.literal('asc'), schema.literal('desc')], {
+    defaultValue: 'desc',
+  }),
+  statuses: schema.maybe(
+    schema.arrayOf(
+      schema.oneOf([
+        schema.literal('success'),
+        schema.literal('error'),
+        schema.literal('skipped'),
+        schema.literal('no_gaps'),
+      ])
+    )
+  ),
+});
+
+export const gapAutoFillSchedulerLogEntrySchema = schema.object({
+  id: schema.string(),
+  timestamp: schema.maybe(schema.string()),
+  status: schema.maybe(schema.string()),
+  message: schema.maybe(schema.string()),
+  results: schema.maybe(
+    schema.arrayOf(
+      schema.object({
+        rule_id: schema.maybe(schema.string()),
+        processed_gaps: schema.maybe(schema.number()),
+        status: schema.maybe(schema.string()),
+        error: schema.maybe(schema.string()),
+      })
+    )
+  ),
+});
+
+export const gapAutoFillSchedulerLogsResponseSchema = schema.object({
+  data: schema.arrayOf(gapAutoFillSchedulerLogEntrySchema),
+  total: schema.number(),
+  page: schema.number(),
+  per_page: schema.number(),
+});

x-pack/platform/plugins/shared/alerting/common/routes/gaps/apis/gap_auto_fill_scheduler/types/v1.ts

@@ -6,15 +6,38 @@
  */
 
 import type { TypeOf } from '@kbn/config-schema';
-import type { gapAutoFillSchedulerBodySchemaV1, gapAutoFillSchedulerResponseSchemaV1 } from '..';
+import type {
+  gapAutoFillSchedulerBodySchemaV1,
+  gapAutoFillSchedulerResponseSchemaV1,
+  gapAutoFillSchedulerUpdateBodySchemaV1,
+  getGapAutoFillSchedulerParamsSchemaV1,
+  gapAutoFillSchedulerLogEntrySchemaV1,
+  gapAutoFillSchedulerLogsResponseSchemaV1,
+  gapAutoFillSchedulerLogsRequestQuerySchemaV1,
+} from '..';
 
 export type GapAutoFillSchedulerRequestBody = TypeOf<typeof gapAutoFillSchedulerBodySchemaV1>;
+export type UpdateGapAutoFillSchedulerRequestBody = TypeOf<
+  typeof gapAutoFillSchedulerUpdateBodySchemaV1
+>;
 export type GapAutoFillSchedulerResponseBody = TypeOf<typeof gapAutoFillSchedulerResponseSchemaV1>;
-
+export type GetGapAutoFillSchedulerParams = TypeOf<typeof getGapAutoFillSchedulerParamsSchemaV1>;
 export interface GapAutoFillSchedulerResponse {
   body: GapAutoFillSchedulerResponseBody;
 }
 
 export interface UpdateGapAutoFillSchedulerResponse {
   body: GapAutoFillSchedulerResponseBody;
 }
+
+export type GapAutoFillSchedulerLogEntry = TypeOf<typeof gapAutoFillSchedulerLogEntrySchemaV1>;
+export type GapAutoFillSchedulerLogsResponseBody = TypeOf<
+  typeof gapAutoFillSchedulerLogsResponseSchemaV1
+>;
+export interface GapAutoFillSchedulerLogsResponse {
+  body: GapAutoFillSchedulerLogsResponseBody;
+}
+
+export type GapAutoFillSchedulerLogsRequestQuery = TypeOf<
+  typeof gapAutoFillSchedulerLogsRequestQuerySchemaV1
+>;

x-pack/platform/plugins/shared/alerting/server/application/gap_auto_fill_scheduler/methods/create/create_gap_auto_fill_scheduler.ts

@@ -112,35 +112,37 @@ Payload summary: ${JSON.stringify(otherParams, (key, value) =>
       savedObjectOptions
     );
 
-    try {
-      await taskManager.ensureScheduled(
-        {
-          id: so.id,
-          taskType: GAP_AUTO_FILL_SCHEDULER_TASK_TYPE,
-          schedule: params.schedule,
-          scope: params.scope ?? [],
-          params: {
-            configId: so.id,
-            spaceId: context.spaceId,
-          },
-          state: {},
-        },
-        {
-          request: params.request,
-        }
-      );
-    } catch (e) {
-      context.logger.error(
-        `Failed to schedule task for gap auto fill scheduler ${so.id}. Will attempt to delete the saved object.`
-      );
+    if (params.enabled) {
       try {
-        await soClient.delete(GAP_AUTO_FILL_SCHEDULER_SAVED_OBJECT_TYPE, so.id);
-      } catch (deleteError) {
+        await taskManager.ensureScheduled(
+          {
+            id: so.id,
+            taskType: GAP_AUTO_FILL_SCHEDULER_TASK_TYPE,
+            schedule: params.schedule,
+            scope: params.scope ?? [],
+            params: {
+              configId: so.id,
+              spaceId: context.spaceId,
+            },
+            state: {},
+          },
+          {
+            request: params.request,
+          }
+        );
+      } catch (e) {
         context.logger.error(
-          `Failed to delete gap auto fill saved object for gap auto fill scheduler ${so.id}.`
+          `Failed to schedule task for gap auto fill scheduler ${so.id}. Will attempt to delete the saved object.`
         );
+        try {
+          await soClient.delete(GAP_AUTO_FILL_SCHEDULER_SAVED_OBJECT_TYPE, so.id);
+        } catch (deleteError) {
+          context.logger.error(
+            `Failed to delete gap auto fill saved object for gap auto fill scheduler ${so.id}.`
+          );
+        }
+        throw e;
       }
-      throw e;
     }
 
     // Log successful creation