[APM] Remove value_count aggregations (elastic#89408)

Co-authored-by: Kibana Machine <[email protected]>
spalger · Feb 1, 2021 · 3255f90 · 3255f90
1 parent 53637d0
commit 3255f90
Show file tree

Hide file tree

Showing 17 changed files with 63 additions and 174 deletions.
diff --git a/x-pack/plugins/apm/server/lib/alerts/chart_preview/get_transaction_error_rate.ts b/x-pack/plugins/apm/server/lib/alerts/chart_preview/get_transaction_error_rate.ts
@@ -44,9 +44,7 @@ export async function getTransactionErrorRateChartPreview({
     },
   };
 
-  const outcomes = getOutcomeAggregation({
-    searchAggregatedTransactions: false,
-  });
+  const outcomes = getOutcomeAggregation();
 
   const { intervalString } = getBucketSize({ start, end, numBuckets: 20 });
 

diff --git a/x-pack/plugins/apm/server/lib/correlations/get_correlations_for_failed_transactions/index.ts b/x-pack/plugins/apm/server/lib/correlations/get_correlations_for_failed_transactions/index.ts
@@ -4,7 +4,7 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-import { isEmpty, omit } from 'lodash';
+import { isEmpty, omit, merge } from 'lodash';
 import { EventOutcome } from '../../../../common/event_outcome';
 import {
   processSignificantTermAggs,
@@ -134,8 +134,7 @@ export async function getErrorRateTimeSeries({
       extended_bounds: { min: start, max: end },
     },
     aggs: {
-      // TODO: add support for metrics
-      outcomes: getOutcomeAggregation({ searchAggregatedTransactions: false }),
+      outcomes: getOutcomeAggregation(),
     },
   };
 
@@ -147,13 +146,12 @@ export async function getErrorRateTimeSeries({
       };
       return acc;
     },
-    {} as Record<
-      string,
-      {
+    {} as {
+      [key: string]: {
         filter: AggregationOptionsByType['filter'];
         aggs: { timeseries: typeof timeseriesAgg };
-      }
-    >
+      };
+    }
   );
 
   const params = {
@@ -162,32 +160,25 @@ export async function getErrorRateTimeSeries({
     body: {
       size: 0,
       query: { bool: { filter: backgroundFilters } },
-      aggs: {
-        // overall aggs
-        timeseries: timeseriesAgg,
-
-        // per term aggs
-        ...perTermAggs,
-      },
+      aggs: merge({ timeseries: timeseriesAgg }, perTermAggs),
     },
   };
 
   const response = await apmEventClient.search(params);
-  type Agg = NonNullable<typeof response.aggregations>;
+  const { aggregations } = response;
 
-  if (!response.aggregations) {
+  if (!aggregations) {
     return {};
   }
 
   return {
     overall: {
       timeseries: getTransactionErrorRateTimeSeries(
-        response.aggregations.timeseries.buckets
+        aggregations.timeseries.buckets
       ),
     },
     significantTerms: topSigTerms.map((topSig, index) => {
-      // @ts-expect-error
-      const agg = response.aggregations[`term_${index}`] as Agg;
+      const agg = aggregations[`term_${index}`]!;
 
       return {
         ...topSig,

diff --git a/x-pack/plugins/apm/server/lib/helpers/transaction_error_rate.ts b/x-pack/plugins/apm/server/lib/helpers/transaction_error_rate.ts
@@ -10,40 +10,21 @@ import {
   AggregationOptionsByType,
   AggregationResultOf,
 } from '../../../../../typings/elasticsearch/aggregations';
-import { getTransactionDurationFieldForAggregatedTransactions } from './aggregated_transactions';
 
-export function getOutcomeAggregation({
-  searchAggregatedTransactions,
-}: {
-  searchAggregatedTransactions: boolean;
-}) {
-  return {
-    terms: {
-      field: EVENT_OUTCOME,
-      include: [EventOutcome.failure, EventOutcome.success],
-    },
-    aggs: {
-      // simply using the doc count to get the number of requests is not possible for transaction metrics (histograms)
-      // to work around this we get the number of transactions by counting the number of latency values
-      count: {
-        value_count: {
-          field: getTransactionDurationFieldForAggregatedTransactions(
-            searchAggregatedTransactions
-          ),
-        },
-      },
-    },
-  };
-}
+export const getOutcomeAggregation = () => ({
+  terms: {
+    field: EVENT_OUTCOME,
+    include: [EventOutcome.failure, EventOutcome.success],
+  },
+});
+
+type OutcomeAggregation = ReturnType<typeof getOutcomeAggregation>;
 
 export function calculateTransactionErrorPercentage(
-  outcomeResponse: AggregationResultOf<
-    ReturnType<typeof getOutcomeAggregation>,
-    {}
-  >
+  outcomeResponse: AggregationResultOf<OutcomeAggregation, {}>
 ) {
   const outcomes = Object.fromEntries(
-    outcomeResponse.buckets.map(({ key, count }) => [key, count.value])
+    outcomeResponse.buckets.map(({ key, doc_count: count }) => [key, count])
   );
 
   const failedTransactions = outcomes[EventOutcome.failure] ?? 0;
@@ -56,7 +37,7 @@ export function getTransactionErrorRateTimeSeries(
   buckets: AggregationResultOf<
     {
       date_histogram: AggregationOptionsByType['date_histogram'];
-      aggs: { outcomes: ReturnType<typeof getOutcomeAggregation> };
+      aggs: { outcomes: OutcomeAggregation };
     },
     {}
   >['buckets']

diff --git a/x-pack/plugins/apm/server/lib/observability_overview/get_transaction_coordinates.ts b/x-pack/plugins/apm/server/lib/observability_overview/get_transaction_coordinates.ts
@@ -11,10 +11,7 @@
 import { rangeFilter } from '../../../common/utils/range_filter';
 import { Coordinates } from '../../../../observability/typings/common';
 import { Setup, SetupTimeRange } from '../helpers/setup_request';
-import {
-  getProcessorEventForAggregatedTransactions,
-  getTransactionDurationFieldForAggregatedTransactions,
-} from '../helpers/aggregated_transactions';
+import { getProcessorEventForAggregatedTransactions } from '../helpers/aggregated_transactions';
 
 export async function getTransactionCoordinates({
   setup,
@@ -49,15 +46,6 @@ export async function getTransactionCoordinates({
             fixed_interval: bucketSize,
             min_doc_count: 0,
           },
-          aggs: {
-            count: {
-              value_count: {
-                field: getTransactionDurationFieldForAggregatedTransactions(
-                  searchAggregatedTransactions
-                ),
-              },
-            },
-          },
         },
       },
     },
@@ -68,7 +56,7 @@ export async function getTransactionCoordinates({
   return (
     aggregations?.distribution.buckets.map((bucket) => ({
       x: bucket.key,
-      y: bucket.count.value / deltaAsMinutes,
+      y: bucket.doc_count / deltaAsMinutes,
     })) || []
   );
 }
diff --git a/x-pack/plugins/apm/server/lib/service_map/get_service_map_service_node_info.test.ts b/x-pack/plugins/apm/server/lib/service_map/get_service_map_service_node_info.test.ts
@@ -52,8 +52,10 @@ describe('getServiceMapServiceNodeInfo', () => {
         apmEventClient: {
           search: () =>
             Promise.resolve({
+              hits: {
+                total: { value: 1 },
+              },
               aggregations: {
-                count: { value: 1 },
                 duration: { value: null },
                 avgCpuUsage: { value: null },
                 avgMemoryUsage: { value: null },

diff --git a/x-pack/plugins/apm/server/lib/service_map/get_service_map_service_node_info.ts b/x-pack/plugins/apm/server/lib/service_map/get_service_map_service_node_info.ts
@@ -162,19 +162,12 @@ async function getTransactionStats({
             ),
           },
         },
-        count: {
-          value_count: {
-            field: getTransactionDurationFieldForAggregatedTransactions(
-              searchAggregatedTransactions
-            ),
-          },
-        },
       },
     },
   };
   const response = await apmEventClient.search(params);
 
-  const totalRequests = response.aggregations?.count.value ?? 0;
+  const totalRequests = response.hits.total.value;
 
   return {
     avgTransactionDuration: response.aggregations?.duration.value ?? null,

diff --git a/x-pack/plugins/apm/server/lib/services/__snapshots__/queries.test.ts.snap b/x-pack/plugins/apm/server/lib/services/__snapshots__/queries.test.ts.snap
diff --git a/...s/apm/server/lib/services/get_service_instances/get_service_instance_transaction_stats.ts b/...s/apm/server/lib/services/get_service_instances/get_service_instance_transaction_stats.ts
@@ -30,18 +30,17 @@ export async function getServiceInstanceTransactionStats({
 }: ServiceInstanceParams) {
   const { apmEventClient, start, end, esFilter } = setup;
 
-  const { intervalString } = getBucketSize({ start, end, numBuckets });
+  const { intervalString, bucketSize } = getBucketSize({
+    start,
+    end,
+    numBuckets,
+  });
 
   const field = getTransactionDurationFieldForAggregatedTransactions(
     searchAggregatedTransactions
   );
 
   const subAggs = {
-    count: {
-      value_count: {
-        field,
-      },
-    },
     avg_transaction_duration: {
       avg: {
         field,
@@ -53,13 +52,6 @@ export async function getServiceInstanceTransactionStats({
           [EVENT_OUTCOME]: EventOutcome.failure,
         },
       },
-      aggs: {
-        count: {
-          value_count: {
-            field,
-          },
-        },
-      },
     },
   };
 
@@ -113,12 +105,13 @@ export async function getServiceInstanceTransactionStats({
   });
 
   const deltaAsMinutes = (end - start) / 60 / 1000;
+  const bucketSizeInMinutes = bucketSize / 60;
 
   return (
     response.aggregations?.[SERVICE_NODE_NAME].buckets.map(
       (serviceNodeBucket) => {
         const {
-          count,
+          doc_count: count,
           avg_transaction_duration: avgTransactionDuration,
           key,
           failures,
@@ -128,17 +121,17 @@ export async function getServiceInstanceTransactionStats({
         return {
           serviceNodeName: String(key),
           errorRate: {
-            value: failures.count.value / count.value,
+            value: failures.doc_count / count,
             timeseries: timeseries.buckets.map((dateBucket) => ({
               x: dateBucket.key,
-              y: dateBucket.failures.count.value / dateBucket.count.value,
+              y: dateBucket.failures.doc_count / dateBucket.doc_count,
             })),
           },
           throughput: {
-            value: count.value / deltaAsMinutes,
+            value: count / deltaAsMinutes,
             timeseries: timeseries.buckets.map((dateBucket) => ({
               x: dateBucket.key,
-              y: dateBucket.count.value / deltaAsMinutes,
+              y: dateBucket.doc_count / bucketSizeInMinutes,
             })),
           },
           latency: {

diff --git a/...lib/services/get_service_transaction_groups/get_timeseries_data_for_transaction_groups.ts b/...lib/services/get_service_transaction_groups/get_timeseries_data_for_transaction_groups.ts
@@ -17,6 +17,7 @@ import {
 
 import { ESFilter } from '../../../../../../typings/elasticsearch';
 import {
+  getDocumentTypeFilterForAggregatedTransactions,
   getProcessorEventForAggregatedTransactions,
   getTransactionDurationFieldForAggregatedTransactions,
 } from '../../helpers/aggregated_transactions';
@@ -76,6 +77,9 @@ export async function getTimeseriesDataForTransactionGroups({
             { term: { [SERVICE_NAME]: serviceName } },
             { term: { [TRANSACTION_TYPE]: transactionType } },
             { range: rangeFilter(start, end) },
+            ...getDocumentTypeFilterForAggregatedTransactions(
+              searchAggregatedTransactions
+            ),
             ...esFilter,
           ],
         },
@@ -99,10 +103,8 @@ export async function getTimeseriesDataForTransactionGroups({
               },
               aggs: {
                 ...getLatencyAggregation(latencyAggregationType, field),
-                transaction_count: { value_count: { field } },
                 [EVENT_OUTCOME]: {
                   filter: { term: { [EVENT_OUTCOME]: EventOutcome.failure } },
-                  aggs: { transaction_count: { value_count: { field } } },
                 },
               },
             },