[ResponseOps][Alerting] Decouple feature IDs from consumers

packages/kbn-alerting-types/search_strategy_types.ts

@@ -8,7 +8,6 @@
  */
 
 import type { IEsSearchRequest, IEsSearchResponse } from '@kbn/search-types';
-import type { ValidFeatureId } from '@kbn/rule-data-utils';
 import type {
   MappingRuntimeFields,
   QueryDslFieldAndFormat,
@@ -18,7 +17,8 @@ import type {
 import type { Alert } from './alert_type';
 
 export type RuleRegistrySearchRequest = IEsSearchRequest & {
-  featureIds: ValidFeatureId[];
+  ruleTypeIds: string[];
+  consumers?: string[];
   fields?: QueryDslFieldAndFormat[];
   query?: Pick<QueryDslQueryContainer, 'bool' | 'ids'>;
   sort?: SortCombinations[];

packages/kbn-alerts-as-data-utils/src/schemas/generated/observability_threshold_schema.ts

 const ruleTypes = await supertest 
 alerts: MetricsRulesTypeAlertDefinition, 
 const ruleTypes = await supertest 
@@ -0,0 +1,90 @@
+/*
+ * 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", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+// ---------------------------------- WARNING ----------------------------------
+// this file was generated, and should not be edited by hand
+// ---------------------------------- WARNING ----------------------------------
+import * as rt from 'io-ts';
+import { Either } from 'fp-ts/lib/Either';
+import { AlertSchema } from './alert_schema';
+import { EcsSchema } from './ecs_schema';
+const ISO_DATE_PATTERN = /^d{4}-d{2}-d{2}Td{2}:d{2}:d{2}.d{3}Z$/;
+export const IsoDateString = new rt.Type<string, string, unknown>(
+  'IsoDateString',
+  rt.string.is,
+  (input, context): Either<rt.Errors, string> => {
+    if (typeof input === 'string' && ISO_DATE_PATTERN.test(input)) {
+      return rt.success(input);
+    } else {
+      return rt.failure(input, context);
+    }
+  },
+  rt.identity
+);
+export type IsoDateStringC = typeof IsoDateString;
+export const schemaUnknown = rt.unknown;
+export const schemaUnknownArray = rt.array(rt.unknown);
+export const schemaString = rt.string;
+export const schemaStringArray = rt.array(schemaString);
+export const schemaNumber = rt.number;
+export const schemaNumberArray = rt.array(schemaNumber);
+export const schemaDate = rt.union([IsoDateString, schemaNumber]);
+export const schemaDateArray = rt.array(schemaDate);
+export const schemaDateRange = rt.partial({
+  gte: schemaDate,
+  lte: schemaDate,
+});
+export const schemaDateRangeArray = rt.array(schemaDateRange);
+export const schemaStringOrNumber = rt.union([schemaString, schemaNumber]);
+export const schemaStringOrNumberArray = rt.array(schemaStringOrNumber);
+export const schemaBoolean = rt.boolean;
+export const schemaBooleanArray = rt.array(schemaBoolean);
+const schemaGeoPointCoords = rt.type({
+  type: schemaString,
+  coordinates: schemaNumberArray,
+});
+const schemaGeoPointString = schemaString;
+const schemaGeoPointLatLon = rt.type({
+  lat: schemaNumber,
+  lon: schemaNumber,
+});
+const schemaGeoPointLocation = rt.type({
+  location: schemaNumberArray,
+});
+const schemaGeoPointLocationString = rt.type({
+  location: schemaString,
+});
+export const schemaGeoPoint = rt.union([
+  schemaGeoPointCoords,
+  schemaGeoPointString,
+  schemaGeoPointLatLon,
+  schemaGeoPointLocation,
+  schemaGeoPointLocationString,
+]);
+export const schemaGeoPointArray = rt.array(schemaGeoPoint);
+// prettier-ignore
+const ObservabilityThresholdAlertRequired = rt.type({
+});
+// prettier-ignore
+const ObservabilityThresholdAlertOptional = rt.partial({
+  'kibana.alert.context': schemaUnknown,
+  'kibana.alert.evaluation.threshold': schemaStringOrNumber,
+  'kibana.alert.evaluation.value': schemaStringOrNumber,
+  'kibana.alert.evaluation.values': schemaStringOrNumberArray,
+  'kibana.alert.group': rt.array(
+    rt.partial({
+      field: schemaStringArray,
+      value: schemaStringArray,
+    })
+  ),
+});
+
+// prettier-ignore
+export const ObservabilityThresholdAlertSchema = rt.intersection([ObservabilityThresholdAlertRequired, ObservabilityThresholdAlertOptional, AlertSchema, EcsSchema]);
+// prettier-ignore
+export type ObservabilityThresholdAlert = rt.TypeOf<typeof ObservabilityThresholdAlertSchema>;

packages/kbn-alerts-grouping/src/components/alerts_grouping.test.tsx

@@ -23,7 +23,8 @@ import { groupingSearchResponse } from '../mocks/grouping_query.mock';
 import { useAlertsGroupingState } from '../contexts/alerts_grouping_context';
 import { I18nProvider } from '@kbn/i18n-react';
 import {
-  mockFeatureIds,
+  mockRuleTypeIds,
+  mockConsumers,
   mockDate,
   mockGroupingProps,
   mockGroupingId,
@@ -146,7 +147,8 @@ describe('AlertsGrouping', () => {
       expect.objectContaining({
         params: {
           aggregations: {},
-          featureIds: mockFeatureIds,
+          ruleTypeIds: mockRuleTypeIds,
+          consumers: mockConsumers,
           groupByField: 'kibana.alert.rule.name',
           filters: [
             {

packages/kbn-alerts-grouping/src/components/alerts_grouping.tsx

@@ -66,7 +66,7 @@ const AlertsGroupingInternal = <T extends BaseAlertsGroupAggregations>(
   const {
     groupingId,
     services,
-    featureIds,
+    ruleTypeIds,
     defaultGroupingOptions,
     defaultFilters,
     globalFilters,
@@ -79,7 +79,7 @@ const AlertsGroupingInternal = <T extends BaseAlertsGroupAggregations>(
   const { grouping, updateGrouping } = useAlertsGroupingState(groupingId);
 
   const { dataView } = useAlertsDataView({
-    featureIds,
+    ruleTypeIds,
     dataViewsService: dataViews,
     http,
     toasts: notifications.toasts,
@@ -252,7 +252,7 @@ const typedMemo: <T>(c: T) => T = memo;
  *
  * return (
  *   <AlertsGrouping<YourAggregationsType>
- *     featureIds={[...]}
+ *     ruleTypeIds={[...]}
  *     globalQuery={{ query: ..., language: 'kql' }}
  *     globalFilters={...}
  *     from={...}

packages/kbn-alerts-grouping/src/components/alerts_grouping_level.test.tsx

@@ -55,6 +55,10 @@ const mockGroupingLevelProps: Omit<AlertsGroupingLevelProps, 'children'> = {
 describe('AlertsGroupingLevel', () => {
   let buildEsQuerySpy: jest.SpyInstance;
 
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
   beforeAll(() => {
     buildEsQuerySpy = jest.spyOn(buildEsQueryModule, 'buildEsQuery');
   });
@@ -119,4 +123,58 @@ describe('AlertsGroupingLevel', () => {
       Object.keys(groupingSearchResponse.aggregations)
     );
   });
+
+  it('should calls useGetAlertsGroupAggregationsQuery with correct props', () => {
+    render(
+      <AlertsGroupingLevel {...mockGroupingLevelProps}>
+        {() => <span data-test-subj="grouping-level" />}
+      </AlertsGroupingLevel>
+    );
+
+    expect(mockUseGetAlertsGroupAggregationsQuery.mock.calls).toMatchInlineSnapshot(`
+      Array [
+        Array [
+          Object {
+            "enabled": true,
+            "http": Object {
+              "get": [MockFunction],
+            },
+            "params": Object {
+              "aggregations": Object {},
+              "consumers": Array [
+                "stackAlerts",
+              ],
+              "filters": Array [
+                Object {
+                  "bool": Object {
+                    "filter": Array [],
+                    "must": Array [],
+                    "must_not": Array [],
+                    "should": Array [],
+                  },
+                },
+                Object {
+                  "range": Object {
+                    "kibana.alert.time_range": Object {
+                      "gte": "2020-07-07T08:20:18.966Z",
+                      "lte": "2020-07-08T08:20:18.966Z",
+                    },
+                  },
+                },
+              ],
+              "groupByField": "selectedGroup",
+              "pageIndex": 0,
+              "pageSize": 10,
+              "ruleTypeIds": Array [
+                ".es-query",
+              ],
+            },
+            "toasts": Object {
+              "addDanger": [MockFunction],
+            },
+          },
+        ],
+      ]
+    `);
+  });
 });

packages/kbn-alerts-grouping/src/components/alerts_grouping_level.tsx

@@ -46,7 +46,8 @@ const DEFAULT_FILTERS: Filter[] = [];
 const typedMemo: <T>(c: T) => T = memo;
 export const AlertsGroupingLevel = typedMemo(
   <T extends BaseAlertsGroupAggregations>({
-    featureIds,
+    ruleTypeIds,
+    consumers,
     defaultFilters = DEFAULT_FILTERS,
     from,
     getGrouping,
@@ -86,7 +87,8 @@ export const AlertsGroupingLevel = typedMemo(
 
     const aggregationsQuery = useMemo<UseGetAlertsGroupAggregationsQueryProps['params']>(() => {
       return {
-        featureIds,
+        ruleTypeIds,
+        consumers,
         groupByField: selectedGroup,
         aggregations: getAggregationsByGroupingField(selectedGroup)?.reduce(
           (acc, val) => Object.assign(acc, val),
@@ -107,12 +109,13 @@ export const AlertsGroupingLevel = typedMemo(
         pageSize,
       };
     }, [
-      featureIds,
+      consumers,
       filters,
       from,
       getAggregationsByGroupingField,
       pageIndex,
       pageSize,
+      ruleTypeIds,
       selectedGroup,
       to,
     ]);

packages/kbn-alerts-grouping/src/mocks/grouping_props.mock.tsx

@@ -8,12 +8,12 @@
  */
 
 import React from 'react';
-import { AlertConsumers } from '@kbn/rule-data-utils';
 import { AlertsGroupingProps } from '../types';
 
 export const mockGroupingId = 'test';
 
-export const mockFeatureIds = [AlertConsumers.STACK_ALERTS];
+export const mockRuleTypeIds = ['.es-query'];
+export const mockConsumers = ['stackAlerts'];
 
 export const mockDate = {
   from: '2020-07-07T08:20:18.966Z',
@@ -30,7 +30,8 @@ export const mockOptions = [
 export const mockGroupingProps: Omit<AlertsGroupingProps, 'children'> = {
   ...mockDate,
   groupingId: mockGroupingId,
-  featureIds: mockFeatureIds,
+  ruleTypeIds: mockRuleTypeIds,
+  consumers: mockConsumers,
   defaultGroupingOptions: mockOptions,
   getAggregationsByGroupingField: () => [],
   getGroupStats: () => [{ title: 'Stat', component: <span /> }],

packages/kbn-alerts-grouping/src/mocks/grouping_query.mock.ts

@@ -11,12 +11,12 @@ export const getQuery = ({
   selectedGroup,
   uniqueValue,
   timeRange,
-  featureIds,
+  ruleTypeIds,
 }: {
   selectedGroup: string;
   uniqueValue: string;
   timeRange: { from: string; to: string };
-  featureIds: string[];
+  ruleTypeIds: string[];
 }) => ({
   _source: false,
   aggs: {
@@ -52,7 +52,7 @@ export const getQuery = ({
       },
     },
   },
-  feature_ids: featureIds,
+  rule_type_ids: ruleTypeIds,
   query: {
     bool: {
       filter: [

packages/kbn-alerts-grouping/src/types.ts

@@ -8,7 +8,6 @@
  */
 
 import type { Filter, Query } from '@kbn/es-query';
-import { ValidFeatureId } from '@kbn/rule-data-utils';
 import type { NotificationsStart } from '@kbn/core-notifications-browser';
 import type { DataViewsServicePublic } from '@kbn/data-views-plugin/public/types';
 import type { HttpSetup } from '@kbn/core-http-browser';
@@ -63,9 +62,13 @@ export interface AlertsGroupingProps<
    */
   defaultGroupingOptions: GroupOption[];
   /**
-   * The alerting feature ids this grouping covers
+   * The alerting rule type ids this grouping covers
    */
-  featureIds: ValidFeatureId[];
+  ruleTypeIds: string[];
+  /**
+   * The alerting consumers this grouping covers
+   */
+  consumers?: string[];
   /**
    * Time filter start
    */

packages/kbn-alerts-ui-shared/src/action_variables/transforms.test.ts

@@ -289,5 +289,6 @@ function getAlertType(actionVariables: ActionVariables): RuleType {
     producer: ALERTING_FEATURE_ID,
     minimumLicenseRequired: 'basic',
     enabledInLicense: true,
+    category: 'my-category',
   };
 }

packages/kbn-alerts-ui-shared/src/alert_filter_controls/alert_filter_controls.test.tsx

@@ -10,7 +10,6 @@
 import React from 'react';
 import { render, screen } from '@testing-library/react';
 import { AlertFilterControls, AlertFilterControlsProps } from './alert_filter_controls';
-import { AlertConsumers } from '@kbn/rule-data-utils';
 import { DEFAULT_CONTROLS } from './constants';
 import { useAlertsDataView } from '../common/hooks/use_alerts_data_view';
 import { FilterGroup } from './filter_group';
@@ -56,7 +55,7 @@ const ControlGroupRenderer = (() => (
 
 describe('AlertFilterControls', () => {
   const props: AlertFilterControlsProps = {
-    featureIds: [AlertConsumers.STACK_ALERTS],
+    ruleTypeIds: ['.es-query'],
     defaultControls: DEFAULT_CONTROLS,
     dataViewSpec: {
       id: 'alerts-filters-dv',