Add group-by feature in APM rules

x-pack/plugins/apm/common/rules/apm_rule_types.ts

@@ -40,29 +40,33 @@ const THRESHOLD_MET_GROUP: ActionGroup<ThresholdMetActionGroupId> = {
   }),
 };
 
+const formatGroup = (group: string) => (group ? ` for ${group}` : '');
+
 export function formatErrorCountReason({
   threshold,
   measured,
   serviceName,
   windowSize,
   windowUnit,
+  group,
 }: {
   threshold: number;
   measured: number;
   serviceName: string;
   windowSize: number;
   windowUnit: string;
+  group: string;
 }) {
   return i18n.translate('xpack.apm.alertTypes.errorCount.reason', {
-    defaultMessage: `Error count is {measured} in the last {interval} for {serviceName}. Alert when > {threshold}.`,
+    defaultMessage: `Error count is {measured} in the last {interval}{group}. Alert when > {threshold}.`,
     values: {
       threshold,
       measured,
-      serviceName,
       interval: formatDurationFromTimeUnitChar(
         windowSize,
         windowUnit as TimeUnitChar
       ),
+      group: formatGroup(group),
     },
   });
 }
@@ -75,6 +79,7 @@ export function formatTransactionDurationReason({
   aggregationType,
   windowSize,
   windowUnit,
+  group,
 }: {
   threshold: number;
   measured: number;
@@ -83,23 +88,24 @@ export function formatTransactionDurationReason({
   aggregationType: string;
   windowSize: number;
   windowUnit: string;
+  group: string;
 }) {
   let aggregationTypeFormatted =
     aggregationType.charAt(0).toUpperCase() + aggregationType.slice(1);
   if (aggregationTypeFormatted === 'Avg')
     aggregationTypeFormatted = aggregationTypeFormatted + '.';
 
   return i18n.translate('xpack.apm.alertTypes.transactionDuration.reason', {
-    defaultMessage: `{aggregationType} latency is {measured} in the last {interval} for {serviceName}. Alert when > {threshold}.`,
+    defaultMessage: `{aggregationType} latency is {measured} in the last {interval}{group}. Alert when > {threshold}.`,
     values: {
       threshold: asDuration(threshold),
       measured: asDuration(measured),
-      serviceName,
       aggregationType: aggregationTypeFormatted,
       interval: formatDurationFromTimeUnitChar(
         windowSize,
         windowUnit as TimeUnitChar
       ),
+      group: formatGroup(group),
     },
   });
 }
@@ -111,24 +117,26 @@ export function formatTransactionErrorRateReason({
   asPercent,
   windowSize,
   windowUnit,
+  group,
 }: {
   threshold: number;
   measured: number;
   serviceName: string;
   asPercent: AsPercent;
   windowSize: number;
   windowUnit: string;
+  group: string;
 }) {
   return i18n.translate('xpack.apm.alertTypes.transactionErrorRate.reason', {
-    defaultMessage: `Failed transactions is {measured} in the last {interval} for {serviceName}. Alert when > {threshold}.`,
+    defaultMessage: `Failed transactions is {measured} in the last {interval}{group}. Alert when > {threshold}.`,
     values: {
       threshold: asPercent(threshold, 100),
       measured: asPercent(measured, 100),
-      serviceName,
       interval: formatDurationFromTimeUnitChar(
         windowSize,
         windowUnit as TimeUnitChar
       ),
+      group: formatGroup(group),
     },
   });
 }

x-pack/plugins/apm/common/rules/schema.ts

@@ -15,6 +15,9 @@ export const errorCountParamsSchema = schema.object({
   threshold: schema.number(),
   serviceName: schema.maybe(schema.string()),
   environment: schema.string(),
+  groupBy: schema.maybe(
+    schema.oneOf([schema.string(), schema.arrayOf(schema.string())])
+  ),
 });
 
 export const transactionDurationParamsSchema = schema.object({
@@ -29,6 +32,9 @@ export const transactionDurationParamsSchema = schema.object({
     schema.literal(AggregationType.P99),
   ]),
   environment: schema.string(),
+  groupBy: schema.maybe(
+    schema.oneOf([schema.string(), schema.arrayOf(schema.string())])
+  ),
 });
 
 export const anomalyParamsSchema = schema.object({
@@ -52,6 +58,9 @@ export const transactionErrorRateParamsSchema = schema.object({
   transactionType: schema.maybe(schema.string()),
   serviceName: schema.maybe(schema.string()),
   environment: schema.string(),
+  groupBy: schema.maybe(
+    schema.oneOf([schema.string(), schema.arrayOf(schema.string())])
+  ),
 });
 
 type ErrorCountParamsType = TypeOf<typeof errorCountParamsSchema>;

x-pack/plugins/apm/common/utils/get_groupby_terms.test.ts

@@ -0,0 +1,45 @@
+/*
+ * 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 { getGroupByTerms } from './get_groupby_terms';
+
+describe('get terms fields based on group-by', () => {
+  it('returns single terms field', () => {
+    const ruleParams = { groupBy: 'service.name' };
+    const terms = getGroupByTerms(ruleParams.groupBy);
+    expect(terms).toEqual([
+      { field: 'service.name', missing: 'SERVICE_NAME_NOT_DEFINED' },
+    ]);
+  });
+
+  it('returns multiple terms fields', () => {
+    const ruleParams = {
+      groupBy: [
+        'service.name',
+        'service.environment',
+        'transaction.type',
+        'transaction.name',
+      ],
+    };
+    const terms = getGroupByTerms(ruleParams.groupBy);
+    expect(terms).toEqual([
+      { field: 'service.name', missing: 'SERVICE_NAME_NOT_DEFINED' },
+      {
+        field: 'service.environment',
+        missing: 'ENVIRONMENT_NOT_DEFINED',
+      },
+      { field: 'transaction.type', missing: 'TRANSACTION_TYPE_NOT_DEFINED' },
+      { field: 'transaction.name', missing: 'TRANSACTION_NAME_NOT_DEFINED' },
+    ]);
+  });
+
+  it('returns an empty array', () => {
+    const ruleParams = { groupBy: undefined };
+    const terms = getGroupByTerms(ruleParams.groupBy);
+    expect(terms).toEqual([]);
+  });
+});

x-pack/plugins/apm/common/utils/get_groupby_terms.ts

@@ -0,0 +1,21 @@
+/*
+ * 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 { ENVIRONMENT_NOT_DEFINED } from '../environment_filter_values';
+import { SERVICE_ENVIRONMENT } from '../es_fields/apm';
+
+export const getGroupByTerms = (groupBy: string[] | string | undefined) => {
+  return (groupBy ? [groupBy] : []).flat().map((group) => {
+    return {
+      field: group,
+      missing:
+        group === SERVICE_ENVIRONMENT
+          ? ENVIRONMENT_NOT_DEFINED.value
+          : group.replaceAll('.', '_').toUpperCase().concat('_NOT_DEFINED'),
+    };
+  });
+};

x-pack/plugins/apm/public/components/alerting/rule_types/error_count_rule_type/index.tsx

@@ -7,13 +7,15 @@
 
 import { i18n } from '@kbn/i18n';
 import { defaults, omit } from 'lodash';
-import React, { useEffect } from 'react';
+import React, { useCallback, useEffect } from 'react';
 import { CoreStart } from '@kbn/core/public';
 import { useKibana } from '@kbn/kibana-react-plugin/public';
 import {
   ForLastExpression,
   TIME_UNITS,
 } from '@kbn/triggers-actions-ui-plugin/public';
+import { EuiFormRow } from '@elastic/eui';
+import { EuiSpacer } from '@elastic/eui';
 import { ENVIRONMENT_ALL } from '../../../../../common/environment_filter_values';
 import { asInteger } from '../../../../../common/utils/formatters';
 import { useFetcher } from '../../../../hooks/use_fetcher';
@@ -26,13 +28,19 @@ import {
 } from '../../utils/fields';
 import { AlertMetadata, getIntervalAndTimeRange } from '../../utils/helper';
 import { ApmRuleParamsContainer } from '../../ui_components/apm_rule_params_container';
+import { APMRuleGroupBy } from '../../ui_components/apm_rule_group_by';
+import {
+  SERVICE_ENVIRONMENT,
+  SERVICE_NAME,
+} from '../../../../../common/es_fields/apm';
 
 export interface RuleParams {
   windowSize?: number;
   windowUnit?: TIME_UNITS;
   threshold?: number;
   serviceName?: string;
   environment?: string;
+  groupBy?: string | string[] | undefined;
 }
 
 interface Props {
@@ -91,6 +99,13 @@ export function ErrorCountRuleType(props: Props) {
     ]
   );
 
+  const onGroupByChange = useCallback(
+    (group: string[] | string | null) => {
+      setRuleParams('groupBy', group && group.length ? group : '');
+    },
+    [setRuleParams]
+  );
+
   const fields = [
     <ServiceField
       currentValue={params.serviceName}
@@ -138,11 +153,41 @@ export function ErrorCountRuleType(props: Props) {
     />
   );
 
+  const groupAlertsBy = (
+    <>
+      <EuiFormRow
+        label={i18n.translate(
+          'xpack.apm.ruleFlyout.errorCount.createAlertPerText',
+          {
+            defaultMessage: 'Group alerts by',
+          }
+        )}
+        helpText={i18n.translate(
+          'xpack.apm.ruleFlyout.errorCount.createAlertPerHelpText',
+          {
+            defaultMessage:
+              'Create an alert for every unique value. For example: "transaction.name". By default, alert is created for every unique service.name and service.environment.',
+          }
+        )}
+        fullWidth
+        display="rowCompressed"
+      >
+        <APMRuleGroupBy
+          onChange={onGroupByChange}
+          options={{ groupBy: ruleParams.groupBy }}
+          preSelectedOptions={[SERVICE_NAME, SERVICE_ENVIRONMENT]}
+        />
+      </EuiFormRow>
+      <EuiSpacer size="m" />
+    </>
+  );
+
   return (
     <ApmRuleParamsContainer
       minimumWindowSize={{ value: 5, unit: TIME_UNITS.MINUTE }}
       defaultParams={params}
       fields={fields}
+      groupAlertsBy={groupAlertsBy}
       setRuleParams={setRuleParams}
       setRuleProperty={setRuleProperty}
       chartPreview={chartPreview}

x-pack/plugins/apm/public/components/alerting/rule_types/transaction_duration_rule_type/index.tsx

@@ -8,13 +8,15 @@
 import { EuiSelect } from '@elastic/eui';
 import { i18n } from '@kbn/i18n';
 import { defaults, map, omit } from 'lodash';
-import React, { useEffect } from 'react';
+import React, { useCallback, useEffect } from 'react';
 import { CoreStart } from '@kbn/core/public';
 import { useKibana } from '@kbn/kibana-react-plugin/public';
 import {
   ForLastExpression,
   TIME_UNITS,
 } from '@kbn/triggers-actions-ui-plugin/public';
+import { EuiFormRow } from '@elastic/eui';
+import { EuiSpacer } from '@elastic/eui';
 import { AggregationType } from '../../../../../common/rules/apm_rule_types';
 import { ENVIRONMENT_ALL } from '../../../../../common/environment_filter_values';
 import { getDurationFormatter } from '../../../../../common/utils/formatters';
@@ -34,6 +36,12 @@ import {
 import { AlertMetadata, getIntervalAndTimeRange } from '../../utils/helper';
 import { ApmRuleParamsContainer } from '../../ui_components/apm_rule_params_container';
 import { PopoverExpression } from '../../ui_components/popover_expression';
+import { APMRuleGroupBy } from '../../ui_components/apm_rule_group_by';
+import {
+  SERVICE_ENVIRONMENT,
+  SERVICE_NAME,
+  TRANSACTION_TYPE,
+} from '../../../../../common/es_fields/apm';
 
 export interface RuleParams {
   aggregationType: AggregationType;
@@ -43,6 +51,7 @@ export interface RuleParams {
   transactionType: string;
   windowSize: number;
   windowUnit: string;
+  groupBy?: string | string[] | undefined;
 }
 
 const TRANSACTION_ALERT_AGGREGATION_TYPES: Record<AggregationType, string> = {
@@ -142,6 +151,13 @@ export function TransactionDurationRuleType(props: Props) {
     />
   );
 
+  const onGroupByChange = useCallback(
+    (group: string[] | string | null) => {
+      setRuleParams('groupBy', group && group.length ? group : '');
+    },
+    [setRuleParams]
+  );
+
   const fields = [
     <ServiceField
       allowAll={false}
@@ -206,12 +222,46 @@ export function TransactionDurationRuleType(props: Props) {
     />,
   ];
 
+  const groupAlertsBy = (
+    <>
+      <EuiFormRow
+        label={i18n.translate(
+          'xpack.apm.ruleFlyout.transactionDuration.createAlertPerText',
+          {
+            defaultMessage: 'Group alerts by',
+          }
+        )}
+        helpText={i18n.translate(
+          'xpack.apm.ruleFlyout.transactionDuration.createAlertPerHelpText',
+          {
+            defaultMessage:
+              'Create an alert for every unique value. For example: "transaction.name". By default, alert is created for every unique service.name, service.environment and transaction.type.',
+          }
+        )}
+        fullWidth
+        display="rowCompressed"
+      >
+        <APMRuleGroupBy
+          onChange={onGroupByChange}
+          options={{ groupBy: ruleParams.groupBy }}
+          preSelectedOptions={[
+            SERVICE_NAME,
+            SERVICE_ENVIRONMENT,
+            TRANSACTION_TYPE,
+          ]}
+        />
+      </EuiFormRow>
+      <EuiSpacer size="m" />
+    </>
+  );
+
   return (
     <ApmRuleParamsContainer
       minimumWindowSize={{ value: 5, unit: TIME_UNITS.MINUTE }}
       chartPreview={chartPreview}
       defaultParams={params}
       fields={fields}
+      groupAlertsBy={groupAlertsBy}
       setRuleParams={setRuleParams}
       setRuleProperty={setRuleProperty}
     />