[APM] Add transaction name filter in failed transaction rate rule type

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

@@ -51,6 +51,7 @@ export const transactionErrorRateParamsSchema = schema.object({
   windowUnit: schema.string(),
   threshold: schema.number(),
   transactionType: schema.maybe(schema.string()),
+  transactionName: schema.maybe(schema.string()),
   serviceName: schema.maybe(schema.string()),
   environment: schema.string(),
 });

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

@@ -0,0 +1,108 @@
+/*
+ * 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 { Story } from '@storybook/react';
+import React, { ComponentType, useState } from 'react';
+import { CoreStart } from '@kbn/core/public';
+import { createKibanaReactContext } from '@kbn/kibana-react-plugin/public';
+import { RuleParams, TransactionErrorRateRuleType } from '.';
+import { AggregationType } from '../../../../../common/rules/apm_rule_types';
+import { AlertMetadata } from '../../utils/helper';
+import { ENVIRONMENT_ALL } from '../../../../../common/environment_filter_values';
+
+const KibanaReactContext = createKibanaReactContext({
+  notifications: { toasts: { add: () => {} } },
+} as unknown as Partial<CoreStart>);
+
+interface Args {
+  ruleParams: RuleParams;
+  metadata?: AlertMetadata;
+}
+
+export default {
+  title: 'alerting/TransactionErrorRateRuleType',
+  component: TransactionErrorRateRuleType,
+  decorators: [
+    (StoryComponent: ComponentType) => {
+      return (
+        <KibanaReactContext.Provider>
+          <div style={{ width: 400 }}>
+            <StoryComponent />
+          </div>
+        </KibanaReactContext.Provider>
+      );
+    },
+  ],
+};
+
+export const CreatingInApmServiceOverview: Story<Args> = ({
+  ruleParams,
+  metadata,
+}) => {
+  const [params, setParams] = useState<RuleParams>(ruleParams);
+
+  function setRuleParams(property: string, value: any) {
+    setParams({ ...params, [property]: value });
+  }
+
+  return (
+    <TransactionErrorRateRuleType
+      ruleParams={params}
+      metadata={metadata}
+      setRuleParams={setRuleParams}
+      setRuleProperty={() => {}}
+    />
+  );
+};
+
+CreatingInApmServiceOverview.args = {
+  ruleParams: {
+    aggregationType: AggregationType.Avg,
+    environment: 'testEnvironment',
+    serviceName: 'testServiceName',
+    threshold: 1500,
+    transactionType: 'testTransactionType',
+    transactionName: 'GET /api/customer/:id',
+    windowSize: 5,
+    windowUnit: 'm',
+  },
+  metadata: {
+    environment: ENVIRONMENT_ALL.value,
+    serviceName: undefined,
+  },
+};
+
+export const CreatingInStackManagement: Story<Args> = ({
+  ruleParams,
+  metadata,
+}) => {
+  const [params, setParams] = useState<RuleParams>(ruleParams);
+
+  function setRuleParams(property: string, value: any) {
+    setParams({ ...params, [property]: value });
+  }
+
+  return (
+    <TransactionErrorRateRuleType
+      ruleParams={params}
+      metadata={metadata}
+      setRuleParams={setRuleParams}
+      setRuleProperty={() => {}}
+    />
+  );
+};
+
+CreatingInStackManagement.args = {
+  ruleParams: {
+    aggregationType: AggregationType.Avg,
+    environment: 'testEnvironment',
+    threshold: 1500,
+    windowSize: 5,
+    windowUnit: 'm',
+  },
+  metadata: undefined,
+};

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

@@ -23,6 +23,7 @@ import {
   IsAboveField,
   ServiceField,
   TransactionTypeField,
+  TransactionNameField,
 } from '../../utils/fields';
 import { AlertMetadata, getIntervalAndTimeRange } from '../../utils/helper';
 import { ApmRuleParamsContainer } from '../../ui_components/apm_rule_params_container';
@@ -33,6 +34,7 @@ interface RuleParams {
   threshold?: number;
   serviceName?: string;
   transactionType?: string;
+  transactionName?: string;
   environment?: string;
 }
 
@@ -78,6 +80,7 @@ export function TransactionErrorRateRuleType(props: Props) {
                 environment: params.environment,
                 serviceName: params.serviceName,
                 transactionType: params.transactionType,
+                transactionName: params.transactionName,
                 interval,
                 start,
                 end,
@@ -89,6 +92,7 @@ export function TransactionErrorRateRuleType(props: Props) {
     },
     [
       params.transactionType,
+      params.transactionName,
       params.environment,
       params.serviceName,
       params.windowSize,
@@ -102,7 +106,8 @@ export function TransactionErrorRateRuleType(props: Props) {
       onChange={(value) => {
         if (value !== params.serviceName) {
           setRuleParams('serviceName', value);
-          setRuleParams('transactionType', '');
+          setRuleParams('transactionType', undefined);
+          setRuleParams('transactionName', undefined);
           setRuleParams('environment', ENVIRONMENT_ALL.value);
         }
       }}
@@ -117,6 +122,11 @@ export function TransactionErrorRateRuleType(props: Props) {
       onChange={(value) => setRuleParams('environment', value)}
       serviceName={params.serviceName}
     />,
+    <TransactionNameField
+      currentValue={params.transactionName}
+      onChange={(value) => setRuleParams('transactionName', value)}
+      serviceName={params.serviceName}
+    />,
     <IsAboveField
       value={params.threshold}
       unit="%"

x-pack/plugins/apm/server/routes/alerts/rule_types/transaction_error_rate/get_transaction_error_rate_chart_preview.ts

@@ -9,6 +9,7 @@ import { rangeQuery, termQuery } from '@kbn/observability-plugin/server';
 import {
   SERVICE_NAME,
   TRANSACTION_TYPE,
+  TRANSACTION_NAME,
 } from '../../../../../common/es_fields/apm';
 import { environmentQuery } from '../../../../../common/utils/environment_query';
 import { AlertParams } from '../../route';
@@ -39,8 +40,15 @@ export async function getTransactionErrorRateChartPreview({
   apmEventClient: APMEventClient;
   alertParams: AlertParams;
 }): Promise<TransactionErrorRateChartPreviewResponse> {
-  const { serviceName, environment, transactionType, interval, start, end } =
-    alertParams;
+  const {
+    serviceName,
+    environment,
+    transactionType,
+    interval,
+    start,
+    end,
+    transactionName,
+  } = alertParams;
 
   const searchAggregatedTransactions = await getSearchTransactionsEvents({
     config,
@@ -62,6 +70,7 @@ export async function getTransactionErrorRateChartPreview({
           filter: [
             ...termQuery(SERVICE_NAME, serviceName),
             ...termQuery(TRANSACTION_TYPE, transactionType),
+            ...termQuery(TRANSACTION_NAME, transactionName),
             ...rangeQuery(start, end),
             ...environmentQuery(environment),
             ...getDocumentTypeFilterForTransactions(

x-pack/plugins/apm/server/routes/alerts/rule_types/transaction_error_rate/register_transaction_error_rate_rule_type.ts

@@ -32,6 +32,7 @@ import {
   SERVICE_ENVIRONMENT,
   SERVICE_NAME,
   TRANSACTION_TYPE,
+  TRANSACTION_NAME,
 } from '../../../../../common/es_fields/apm';
 import { EventOutcome } from '../../../../../common/event_outcome';
 import {
@@ -86,6 +87,7 @@ export function registerTransactionErrorRateRuleType({
           apmActionVariables.interval,
           apmActionVariables.reason,
           apmActionVariables.serviceName,
+          apmActionVariables.transactionName,
           apmActionVariables.threshold,
           apmActionVariables.transactionType,
           apmActionVariables.triggerValue,
@@ -144,6 +146,7 @@ export function registerTransactionErrorRateRuleType({
                   },
                   ...termQuery(SERVICE_NAME, ruleParams.serviceName),
                   ...termQuery(TRANSACTION_TYPE, ruleParams.transactionType),
+                  ...termQuery(TRANSACTION_NAME, ruleParams.transactionName),
                   ...environmentQuery(ruleParams.environment),
                 ],
               },
@@ -232,6 +235,7 @@ export function registerTransactionErrorRateRuleType({
             serviceName,
             transactionType,
             environment,
+            ruleParams.transactionName,
           ]
             .filter((name) => name)
             .join('_');
@@ -255,6 +259,7 @@ export function registerTransactionErrorRateRuleType({
                 [SERVICE_NAME]: serviceName,
                 ...getEnvironmentEsField(environment),
                 [TRANSACTION_TYPE]: transactionType,
+                [TRANSACTION_NAME]: ruleParams.transactionName,
                 [PROCESSOR_EVENT]: ProcessorEvent.transaction,
                 [ALERT_EVALUATION_VALUE]: errorRate,
                 [ALERT_EVALUATION_THRESHOLD]: ruleParams.threshold,
@@ -272,6 +277,7 @@ export function registerTransactionErrorRateRuleType({
               serviceName,
               threshold: ruleParams.threshold,
               transactionType,
+              transactionName: ruleParams.transactionName,
               triggerValue: asDecimalOrInteger(errorRate),
               viewInAppUrl,
             });

x-pack/test/apm_api_integration/tests/alerts/chart_preview.spec.ts

@@ -83,6 +83,61 @@ export default function ApiTest({ getService }: FtrProviderContext) {
       ).to.equal(true);
     });
 
+    it('transaction_error_rate with transaction name', async () => {
+      const options = {
+        params: {
+          query: {
+            start,
+            end,
+            serviceName: 'opbeans-java',
+            transactionName: 'APIRestController#product',
+            transactionType: 'request',
+            environment: 'ENVIRONMENT_ALL',
+            interval: '5m',
+          },
+        },
+      };
+
+      const response = await apmApiClient.readUser({
+        endpoint: 'GET /internal/apm/rule_types/transaction_error_rate/chart_preview',
+        ...options,
+      });
+
+      expect(response.status).to.be(200);
+      expect(response.body.errorRateChartPreview[0]).to.eql({
+        x: 1627974600000,
+        y: 1,
+      });
+    });
+
+    it('transaction_error_rate with nonexistent transaction name', async () => {
+      const options = {
+        params: {
+          query: {
+            start,
+            end,
+            serviceName: 'opbeans-java',
+            transactionName: 'foo',
+            transactionType: 'request',
+            environment: 'ENVIRONMENT_ALL',
+            interval: '5m',
+          },
+        },
+      };
+
+      const response = await apmApiClient.readUser({
+        endpoint: 'GET /internal/apm/rule_types/transaction_error_rate/chart_preview',
+        ...options,
+      });
+
+      expect(response.status).to.be(200);
+      expect(
+        response.body.errorRateChartPreview.every(
+          (item: { x: number; y: number | null }) => item.y === null
+        )
+      ).to.equal(true);
+    });
+
     it('error_count (with data)', async () => {
       const options = getOptions();
       options.params.query.transactionType = undefined;