[RAC][Alerts as Data] Adds RAC plugin

src/core/utils/default_app_categories.ts

@@ -19,12 +19,20 @@ export const DEFAULT_APP_CATEGORIES: Record<string, AppCategory> = Object.freeze
     euiIconType: 'logoKibana',
     order: 1000,
   },
+  rac: {
+    id: 'rac',
+    label: i18n.translate('core.ui.racNavList.label', {
+      defaultMessage: 'Rules, Alerts, Cases',
+    }),
+    order: 2000,
+    euiIconType: 'logoElasticStack',
+  },
   enterpriseSearch: {
     id: 'enterpriseSearch',
     label: i18n.translate('core.ui.enterpriseSearchNavList.label', {
       defaultMessage: 'Enterprise Search',
     }),
-    order: 2000,
+    order: 3000,
     euiIconType: 'logoEnterpriseSearch',
   },
   observability: {
@@ -33,22 +41,22 @@ export const DEFAULT_APP_CATEGORIES: Record<string, AppCategory> = Object.freeze
       defaultMessage: 'Observability',
     }),
     euiIconType: 'logoObservability',
-    order: 3000,
+    order: 4000,
   },
   security: {
     id: 'securitySolution',
     label: i18n.translate('core.ui.securityNavList.label', {
       defaultMessage: 'Security',
     }),
-    order: 4000,
+    order: 5000,
     euiIconType: 'logoSecurity',
   },
   management: {
     id: 'management',
     label: i18n.translate('core.ui.managementNavList.label', {
       defaultMessage: 'Management',
     }),
-    order: 5000,
+    order: 6000,
     euiIconType: 'managementApp',
   },
 });

typings/elasticsearch/search.d.ts

@@ -370,6 +370,16 @@ export type AggregateOf<
   missing: {
     doc_count: number;
   } & SubAggregateOf<TAggregationContainer, TDocument>;
+  multi_terms: {
+    doc_count_error_upper_bound: number;
+    sum_other_doc_count: number;
+    buckets: Array<
+      {
+        doc_count: number;
+        key: string[];
+      } & SubAggregateOf<TAggregationContainer, TDocument>
+    >;
+  };
   nested: {
     doc_count: number;
   } & SubAggregateOf<TAggregationContainer, TDocument>;

x-pack/plugins/alerting/server/task_runner/task_runner.ts

@@ -539,11 +539,16 @@ export class TaskRunner<
           };
         },
         (err: Error) => {
-          const message = `Executing Alert "${alertId}" has resulted in Error: ${err.message}`;
+          const error = new Error(
+            `Executing Alert "${alertId}" has resulted in Error: ${err.message}`
+          );
+
+          Object.assign(error, { wrapped: err });
+
           if (isAlertSavedObjectNotFoundError(err, alertId)) {
-            this.logger.debug(message);
+            this.logger.debug(error.message);
           } else {
-            this.logger.error(message);
+            this.logger.error(error);
           }
           return originalState;
         }

x-pack/plugins/apm/kibana.json

@@ -9,15 +9,15 @@
     "licensing",
     "triggersActionsUi",
     "embeddable",
-    "infra"
+    "infra",
+    "observability"
   ],
   "optionalPlugins": [
     "cloud",
     "usageCollection",
     "taskManager",
     "actions",
     "alerting",
-    "observability",
     "security",
     "ml",
     "home",

x-pack/plugins/apm/server/lib/alerts/action_variables.ts

@@ -13,28 +13,28 @@ export const apmActionVariables = {
       'xpack.apm.alerts.action_variables.serviceName',
       { defaultMessage: 'The service the alert is created for' }
     ),
-    name: 'serviceName',
+    name: 'serviceName' as const,
   },
   transactionType: {
     description: i18n.translate(
       'xpack.apm.alerts.action_variables.transactionType',
       { defaultMessage: 'The transaction type the alert is created for' }
     ),
-    name: 'transactionType',
+    name: 'transactionType' as const,
   },
   environment: {
     description: i18n.translate(
       'xpack.apm.alerts.action_variables.environment',
       { defaultMessage: 'The transaction type the alert is created for' }
     ),
-    name: 'environment',
+    name: 'environment' as const,
   },
   threshold: {
     description: i18n.translate('xpack.apm.alerts.action_variables.threshold', {
       defaultMessage:
         'Any trigger value above this value will cause the alert to fire',
     }),
-    name: 'threshold',
+    name: 'threshold' as const,
   },
   triggerValue: {
     description: i18n.translate(
@@ -44,7 +44,7 @@ export const apmActionVariables = {
           'The value that breached the threshold and triggered the alert',
       }
     ),
-    name: 'triggerValue',
+    name: 'triggerValue' as const,
   },
   interval: {
     description: i18n.translate(
@@ -54,6 +54,6 @@ export const apmActionVariables = {
           'The length and unit of the time period where the alert conditions were met',
       }
     ),
-    name: 'interval',
+    name: 'interval' as const,
   },
 };

x-pack/plugins/apm/server/lib/alerts/alerting_es_client.ts

@@ -5,28 +5,24 @@
  * 2.0.
  */
 
-import { ApiResponse } from '@elastic/elasticsearch';
-import { ThresholdMetActionGroupId } from '../../../common/alert_types';
 import {
   ESSearchRequest,
   ESSearchResponse,
 } from '../../../../../../typings/elasticsearch';
-import {
-  AlertInstanceContext,
-  AlertInstanceState,
-  AlertServices,
-} from '../../../../alerting/server';
+import { AlertServices } from '../../../../alerting/server';
 
-export function alertingEsClient<TParams extends ESSearchRequest>(
-  services: AlertServices<
-    AlertInstanceState,
-    AlertInstanceContext,
-    ThresholdMetActionGroupId
-  >,
+export async function alertingEsClient<TParams extends ESSearchRequest>(
+  scopedClusterClient: AlertServices<
+    never,
+    never,
+    never
+  >['scopedClusterClient'],
   params: TParams
-): Promise<ApiResponse<ESSearchResponse<unknown, TParams>>> {
-  return (services.scopedClusterClient.asCurrentUser.search({
+): Promise<ESSearchResponse<unknown, TParams>> {
+  const response = await scopedClusterClient.asCurrentUser.search({
     ...params,
     ignore_unavailable: true,
-  }) as unknown) as Promise<ApiResponse<ESSearchResponse<unknown, TParams>>>;
+  });
+
+  return (response.body as unknown) as ESSearchResponse<unknown, TParams>;
 }

x-pack/plugins/apm/server/lib/alerts/register_apm_alerts.ts

@@ -6,38 +6,25 @@
  */
 
 import { Observable } from 'rxjs';
-import { AlertingPlugin } from '../../../../alerting/server';
-import { ActionsPlugin } from '../../../../actions/server';
+import { Logger } from 'kibana/server';
 import { registerTransactionDurationAlertType } from './register_transaction_duration_alert_type';
 import { registerTransactionDurationAnomalyAlertType } from './register_transaction_duration_anomaly_alert_type';
 import { registerErrorCountAlertType } from './register_error_count_alert_type';
 import { APMConfig } from '../..';
 import { MlPluginSetup } from '../../../../ml/server';
 import { registerTransactionErrorRateAlertType } from './register_transaction_error_rate_alert_type';
+import { APMRuleRegistry } from '../../plugin';
 
-interface Params {
-  alerting: AlertingPlugin['setup'];
-  actions: ActionsPlugin['setup'];
+export interface RegisterRuleDependencies {
+  registry: APMRuleRegistry;
   ml?: MlPluginSetup;
   config$: Observable<APMConfig>;
+  logger: Logger;
 }
 
-export function registerApmAlerts(params: Params) {
-  registerTransactionDurationAlertType({
-    alerting: params.alerting,
-    config$: params.config$,
-  });
-  registerTransactionDurationAnomalyAlertType({
-    alerting: params.alerting,
-    ml: params.ml,
-    config$: params.config$,
-  });
-  registerErrorCountAlertType({
-    alerting: params.alerting,
-    config$: params.config$,
-  });
-  registerTransactionErrorRateAlertType({
-    alerting: params.alerting,
-    config$: params.config$,
-  });
+export function registerApmAlerts(dependencies: RegisterRuleDependencies) {
+  registerTransactionDurationAlertType(dependencies);
+  registerTransactionDurationAnomalyAlertType(dependencies);
+  registerErrorCountAlertType(dependencies);
+  registerTransactionErrorRateAlertType(dependencies);
 }