[APM] Use the outcome field to calculate the transaction error rate chart

x-pack/plugins/apm/common/elasticsearch_fieldnames.ts

@@ -45,6 +45,8 @@ export const TRANSACTION_SAMPLED = 'transaction.sampled';
 export const TRANSACTION_BREAKDOWN_COUNT = 'transaction.breakdown.count';
 export const TRANSACTION_PAGE_URL = 'transaction.page.url';
 
+export const EVENT_OUTCOME = 'event.outcome';
+
 export const TRACE_ID = 'trace.id';
 
 export const SPAN_DURATION = 'span.duration.us';

x-pack/plugins/apm/common/event_outcome.ts

@@ -0,0 +1,11 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+export enum EventOutcome {
+  success = 'success',
+  failure = 'failure',
+  unknown = 'unknown',
+}

x-pack/plugins/apm/server/lib/transaction_groups/get_error_rate.ts

@@ -4,11 +4,12 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 import { mean } from 'lodash';
+import { EventOutcome } from '../../../common/event_outcome';
 import {
-  HTTP_RESPONSE_STATUS_CODE,
   TRANSACTION_NAME,
   TRANSACTION_TYPE,
   SERVICE_NAME,
+  EVENT_OUTCOME,
 } from '../../../common/elasticsearch_fieldnames';
 import { ProcessorEvent } from '../../../common/processor_event';
 import { rangeFilter } from '../../../common/utils/range_filter';
@@ -42,7 +43,9 @@ export async function getErrorRate({
   const filter = [
     { term: { [SERVICE_NAME]: serviceName } },
     { range: rangeFilter(start, end) },
-    { exists: { field: HTTP_RESPONSE_STATUS_CODE } },
+    {
+      terms: { [EVENT_OUTCOME]: [EventOutcome.failure, EventOutcome.success] },
+    },
     ...transactionNamefilter,
     ...transactionTypefilter,
     ...uiFiltersES,
@@ -65,7 +68,7 @@ export async function getErrorRate({
           },
           aggs: {
             erroneous_transactions: {
-              filter: { range: { [HTTP_RESPONSE_STATUS_CODE]: { gte: 400 } } },
+              filter: { term: { [EVENT_OUTCOME]: EventOutcome.failure } },
             },
           },
         },

x-pack/test/apm_api_integration/basic/tests/settings/agent_configuration.ts

@@ -130,13 +130,24 @@ export default function agentConfigurationTests({ getService }: FtrProviderConte
 
       it('returns all services', async () => {
         const { body } = await getServices();
-        expect(body).to.eql(['ALL_OPTION_VALUE', 'client', 'opbeans-java', 'opbeans-node']);
+        expect(body).to.eql([
+          'ALL_OPTION_VALUE',
+          'client',
+          'opbeans-dotnet',
+          'opbeans-go',
+          'opbeans-java',
+          'opbeans-node',
+          'opbeans-python',
+          'opbeans-ruby',
+          'opbeans-rum',
+        ]);
       });
 
       it('returns the environments', async () => {
         const { body } = await getEnvironments('opbeans-node');
         expect(body).to.eql([
           { name: 'ALL_OPTION_VALUE', alreadyConfigured: false },
+          { name: 'testing', alreadyConfigured: false },
           { name: 'production', alreadyConfigured: false },
         ]);
       });

x-pack/test/apm_api_integration/basic/tests/transaction_groups/error_rate.ts

@@ -4,23 +4,23 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 import expect from '@kbn/expect';
+import { first, last } from 'lodash';
 import { FtrProviderContext } from '../../../common/ftr_provider_context';
-import expectedErrorRate from './expectation/error_rate.json';
 
 export default function ApiTest({ getService }: FtrProviderContext) {
   const supertest = getService('supertest');
   const esArchiver = getService('esArchiver');
 
   // url parameters
-  const start = encodeURIComponent('2020-06-29T06:45:00.000Z');
-  const end = encodeURIComponent('2020-06-29T06:49:00.000Z');
+  const start = encodeURIComponent('2020-08-26T11:00:00.000Z');
+  const end = encodeURIComponent('2020-08-26T11:30:00.000Z');
   const uiFilters = encodeURIComponent(JSON.stringify({}));
 
   describe('Error rate', () => {
     describe('when data is not loaded', () => {
       it('handles the empty state', async () => {
         const response = await supertest.get(
-          `/api/apm/services/opbeans-node/transaction_groups/error_rate?start=${start}&end=${end}&uiFilters=${uiFilters}`
+          `/api/apm/services/opbeans-java/transaction_groups/error_rate?start=${start}&end=${end}&uiFilters=${uiFilters}`
         );
         expect(response.status).to.be(200);
         expect(response.body).to.eql({
@@ -34,13 +34,37 @@ export default function ApiTest({ getService }: FtrProviderContext) {
       before(() => esArchiver.load('8.0.0'));
       after(() => esArchiver.unload('8.0.0'));
 
-      it('returns the transaction error rate', async () => {
-        const response = await supertest.get(
-          `/api/apm/services/opbeans-node/transaction_groups/error_rate?start=${start}&end=${end}&uiFilters=${uiFilters}`
-        );
+      describe('returns the transaction error rate', () => {
+        let errorRateResponse: {
+          erroneousTransactionsRate: Array<{ x: number; y: number | null }>;
+          average: number;
+        };
+        before(async () => {
+          const response = await supertest.get(
+            `/api/apm/services/opbeans-java/transaction_groups/error_rate?start=${start}&end=${end}&uiFilters=${uiFilters}`
+          );
+          errorRateResponse = response.body;
+        });
 
-        expect(response.status).to.be(200);
-        expect(response.body).to.eql(expectedErrorRate);
+        it('has the correct start date', async () => {
+          expect(first(errorRateResponse.erroneousTransactionsRate)?.x).to.be(1598439600000);
+        });
+
+        it('has the correct end date', async () => {
+          expect(last(errorRateResponse.erroneousTransactionsRate)?.x).to.be(1598441400000);
+        });
+
+        it('has the correct number of buckets', async () => {
+          expect(errorRateResponse.erroneousTransactionsRate.length).to.be(61);
+        });
+
+        it('has the correct calculation for average', async () => {
+          expect(errorRateResponse.average).to.be(0.18894993894993897);
+        });
+
+        it('has the correct error rate', async () => {
+          expect(first(errorRateResponse.erroneousTransactionsRate)?.y).to.be(0.5);
+        });
       });
     });
   });