[APM] Use status_code field to calculate error rate

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

@@ -24,6 +24,7 @@ export const AGENT_VERSION = 'agent.version';
 
 export const URL_FULL = 'url.full';
 export const HTTP_REQUEST_METHOD = 'http.request.method';
+export const HTTP_RESPONSE_STATUS_CODE = 'http.response.status_code';
 export const USER_ID = 'user.id';
 export const USER_AGENT_ORIGINAL = 'user_agent.original';
 export const USER_AGENT_NAME = 'user_agent.name';

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

@@ -4,9 +4,9 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 import {
-  ERROR_GROUP_ID,
   PROCESSOR_EVENT,
   SERVICE_NAME,
+  HTTP_RESPONSE_STATUS_CODE,
 } from '../../../common/elasticsearch_fieldnames';
 import { ProcessorEvent } from '../../../common/processor_event';
 import { getMetricsDateHistogramParams } from '../helpers/metrics';
@@ -17,6 +17,9 @@ import {
 } from '../helpers/setup_request';
 import { rangeFilter } from '../../../common/utils/range_filter';
 
+// Regex for 5xx and 4xx
+const errorStatusCodeRegex = /5\d{2}|4\d{2}/;
+
 export async function getErrorRate({
   serviceName,
   groupId,
@@ -30,80 +33,49 @@ export async function getErrorRate({
 
   const filter = [
     { term: { [SERVICE_NAME]: serviceName } },
+    { term: { [PROCESSOR_EVENT]: ProcessorEvent.transaction } },
     { range: rangeFilter(start, end) },
     ...uiFiltersES,
   ];
 
-  const aggs = {
-    response_times: {
-      date_histogram: getMetricsDateHistogramParams(start, end),
-    },
-  };
-
-  const getTransactionBucketAggregation = async () => {
-    const resp = await client.search({
-      index: indices['apm_oss.transactionIndices'],
-      body: {
-        size: 0,
-        query: {
-          bool: {
-            filter: [
-              ...filter,
-              { term: { [PROCESSOR_EVENT]: ProcessorEvent.transaction } },
-            ],
-          },
-        },
-        aggs,
+  const params = {
+    index: indices['apm_oss.transactionIndices'],
+    body: {
+      size: 0,
+      query: {
+        bool: { filter },
       },
-    });
-    return {
-      totalHits: resp.hits.total.value,
-      responseTimeBuckets: resp.aggregations?.response_times.buckets,
-    };
-  };
-  const getErrorBucketAggregation = async () => {
-    const groupIdFilter = groupId
-      ? [{ term: { [ERROR_GROUP_ID]: groupId } }]
-      : [];
-    const resp = await client.search({
-      index: indices['apm_oss.errorIndices'],
-      body: {
-        size: 0,
-        query: {
-          bool: {
-            filter: [
-              ...filter,
-              ...groupIdFilter,
-              { term: { [PROCESSOR_EVENT]: ProcessorEvent.error } },
-            ],
+      aggs: {
+        histogram: {
+          date_histogram: getMetricsDateHistogramParams(start, end),
+          aggs: {
+            statusAggregation: {
+              terms: {
+                field: HTTP_RESPONSE_STATUS_CODE,
+                size: 10,
+              },
+            },
           },
         },
-        aggs,
       },
-    });
-    return resp.aggregations?.response_times.buckets;
+    },
   };
+  const resp = await client.search(params);
+  const noHits = resp.hits.total.value === 0;
 
-  const [transactions, errorResponseTimeBuckets] = await Promise.all([
-    getTransactionBucketAggregation(),
-    getErrorBucketAggregation(),
-  ]);
-
-  const transactionCountByTimestamp: Record<number, number> = {};
-  if (transactions?.responseTimeBuckets) {
-    transactions.responseTimeBuckets.forEach((bucket) => {
-      transactionCountByTimestamp[bucket.key] = bucket.doc_count;
+  const errorRates = resp.aggregations?.histogram.buckets.map((bucket) => {
+    let errorCount = 0;
+    let total = 0;
+    bucket.statusAggregation.buckets.forEach(({ key, doc_count: count }) => {
+      if (errorStatusCodeRegex.test(key.toString())) {
+        errorCount += count;
+      }
+      total += count;
     });
-  }
-
-  const errorRates = errorResponseTimeBuckets?.map((bucket) => {
-    const { key, doc_count: errorCount } = bucket;
-    const relativeRate = errorCount / transactionCountByTimestamp[key];
-    return { x: key, y: relativeRate };
+    return {
+      x: bucket.key,
+      y: noHits ? null : errorCount / total,
+    };
   });
-
-  return {
-    noHits: transactions?.totalHits === 0,
-    errorRates,
-  };
+  return { noHits, errorRates };
 }