[APM] Remove rate aggregations

x-pack/plugins/apm/common/utils/formatters/duration.ts

@@ -13,8 +13,6 @@ import { asDecimalOrInteger, asInteger, asDecimal } from './formatters';
 import { TimeUnit } from './datetime';
 import { Maybe } from '../../../typings/common';
 import { isFiniteNumber } from '../is_finite_number';
-// eslint-disable-next-line @kbn/eslint/no-restricted-paths
-import type { ThroughputUnit } from '../../../server/lib/helpers/calculate_throughput';
 
 interface FormatterOptions {
   defaultValue?: string;
@@ -182,10 +180,12 @@ export function asTransactionRate(value: Maybe<number>) {
   });
 }
 
-export function asExactTransactionRate(value: number, unit: ThroughputUnit) {
+export function asExactTransactionRate(value: number) {
   return i18n.translate('xpack.apm.exactTransactionRateLabel', {
-    defaultMessage: `{value} { unit, select, minute {tpm} other {tps} }`,
-    values: { value: asDecimalOrInteger(value), unit },
+    defaultMessage: `{value} tpm`,
+    values: {
+      value: asDecimalOrInteger(value),
+    },
   });
 }
 

x-pack/plugins/apm/public/components/app/service_overview/service_overview_throughput_chart.tsx

@@ -123,29 +123,16 @@ export function ServiceOverviewThroughputChart({
                 'xpack.apm.serviceOverview.throughtputChartTitle',
                 { defaultMessage: 'Throughput' }
               )}
-              {data.throughputUnit === 'second'
-                ? i18n.translate(
-                    'xpack.apm.serviceOverview.throughtputPerSecondChartTitle',
-                    { defaultMessage: ' (per second)' }
-                  )
-                : ''}
             </h2>
           </EuiTitle>
         </EuiFlexItem>
 
         <EuiFlexItem grow={false}>
           <EuiIconTip
-            content={
-              data.throughputUnit === 'minute'
-                ? i18n.translate('xpack.apm.serviceOverview.tpmHelp', {
-                    defaultMessage:
-                      'Throughput is measured in transactions per minute (tpm)',
-                  })
-                : i18n.translate('xpack.apm.serviceOverview.tpsHelp', {
-                    defaultMessage:
-                      'Throughput is measured in transactions per second (tps)',
-                  })
-            }
+            content={i18n.translate('xpack.apm.serviceOverview.tpmHelp', {
+              defaultMessage:
+                'Throughput is measured in transactions per minute (tpm)',
+            })}
             position="right"
           />
         </EuiFlexItem>
@@ -157,7 +144,7 @@ export function ServiceOverviewThroughputChart({
         showAnnotations={false}
         fetchStatus={status}
         timeseries={timeseries}
-        yLabelFormat={(y) => asExactTransactionRate(y, data.throughputUnit)}
+        yLabelFormat={asExactTransactionRate}
         customTheme={comparisonChartTheme}
       />
     </EuiPanel>

x-pack/plugins/apm/public/services/rest/apm_observability_overview_fetchers.test.ts

@@ -23,7 +23,8 @@ describe('Observability dashboard data', () => {
       start: 'now-15m',
       end: 'now',
     },
-    bucketSize: '600s',
+    bucketSize: 600,
+    intervalString: '600s',
   };
   afterEach(() => {
     callApmApiMock.mockClear();

x-pack/plugins/apm/public/services/rest/apm_observability_overview_fetchers.ts

@@ -15,6 +15,7 @@ export const fetchObservabilityOverviewPageData = async ({
   absoluteTime,
   relativeTime,
   bucketSize,
+  intervalString,
 }: FetchDataParams): Promise<ApmFetchDataResponse> => {
   const data = await callApmApi({
     endpoint: 'GET /api/apm/observability_overview',
@@ -24,6 +25,7 @@ export const fetchObservabilityOverviewPageData = async ({
         start: new Date(absoluteTime.start).toISOString(),
         end: new Date(absoluteTime.end).toISOString(),
         bucketSize,
+        intervalString,
       },
     },
   });

x-pack/plugins/apm/server/lib/backends/get_throughput_charts_for_backend.ts

@@ -13,8 +13,9 @@ import { environmentQuery } from '../../../common/utils/environment_query';
 import { kqlQuery, rangeQuery } from '../../../../observability/server';
 import { ProcessorEvent } from '../../../common/processor_event';
 import { Setup } from '../helpers/setup_request';
-import { getMetricsDateHistogramParams } from '../helpers/metrics';
 import { getOffsetInMs } from '../../../common/utils/get_offset_in_ms';
+import { calculateThroughputWithInterval } from '../helpers/calculate_throughput';
+import { getBucketSize } from '../helpers/get_bucket_size';
 
 export async function getThroughputChartsForBackend({
   backendName,
@@ -41,6 +42,12 @@ export async function getThroughputChartsForBackend({
     offset,
   });
 
+  const { intervalString, bucketSize } = getBucketSize({
+    start: startWithOffset,
+    end: endWithOffset,
+    minBucketSize: 60,
+  });
+
   const response = await apmEventClient.search('get_throughput_for_backend', {
     apm: {
       events: [ProcessorEvent.metric],
@@ -59,16 +66,16 @@ export async function getThroughputChartsForBackend({
       },
       aggs: {
         timeseries: {
-          date_histogram: getMetricsDateHistogramParams({
-            start: startWithOffset,
-            end: endWithOffset,
-            metricsInterval: 60,
-          }),
+          date_histogram: {
+            field: '@timestamp',
+            fixed_interval: intervalString,
+            min_doc_count: 0,
+            extended_bounds: { min: startWithOffset, max: endWithOffset },
+          },
           aggs: {
-            throughput: {
-              rate: {
+            sumSpanDestination: {
+              sum: {
                 field: SPAN_DESTINATION_SERVICE_RESPONSE_TIME_COUNT,
-                unit: 'minute',
               },
             },
           },
@@ -81,7 +88,10 @@ export async function getThroughputChartsForBackend({
     response.aggregations?.timeseries.buckets.map((bucket) => {
       return {
         x: bucket.key + offsetInMs,
-        y: bucket.throughput.value,
+        y: calculateThroughputWithInterval({
+          bucketSize,
+          value: bucket.sumSpanDestination.value || 0,
+        }),
       };
     }) ?? []
   );

x-pack/plugins/apm/server/lib/connections/get_connection_stats/index.ts

@@ -12,7 +12,7 @@ import { joinByKey } from '../../../../common/utils/join_by_key';
 import { Setup } from '../../helpers/setup_request';
 import { getStats } from './get_stats';
 import { getDestinationMap } from './get_destination_map';
-import { calculateThroughput } from '../../helpers/calculate_throughput';
+import { calculateThroughputWithRange } from '../../helpers/calculate_throughput';
 import { withApmSpan } from '../../../utils/with_apm_span';
 
 export function getConnectionStats({
@@ -123,18 +123,15 @@ export function getConnectionStats({
         throughput: {
           value:
             mergedStats.value.count > 0
-              ? calculateThroughput({
+              ? calculateThroughputWithRange({
                   start,
                   end,
                   value: mergedStats.value.count,
                 })
               : null,
           timeseries: mergedStats.timeseries.map((point) => ({
             x: point.x,
-            y:
-              point.count > 0
-                ? calculateThroughput({ start, end, value: point.count })
-                : null,
+            y: point.count, // sparklines only shows trend (no axis)
           })),
         },
         errorRate: {

x-pack/plugins/apm/server/lib/helpers/calculate_throughput.ts

@@ -7,15 +7,26 @@
 
 import { SetupTimeRange } from './setup_request';
 
-export function calculateThroughput({
+export function calculateThroughputWithRange({
   start,
   end,
   value,
-}: SetupTimeRange & { value: number }) {
+}: SetupTimeRange & { value: number; unit?: ThroughputUnit }) {
   const durationAsMinutes = (end - start) / 1000 / 60;
   return value / durationAsMinutes;
 }
 
+export function calculateThroughputWithInterval({
+  bucketSize,
+  value,
+}: {
+  bucketSize: number;
+  value: number;
+}) {
+  const durationAsMinutes = bucketSize / 60;
+  return value / durationAsMinutes;
+}
+
 export type ThroughputUnit = 'minute' | 'second';
 export function getThroughputUnit(bucketSize: number): ThroughputUnit {
   return bucketSize >= 60 ? 'minute' : 'second';

x-pack/plugins/apm/server/lib/observability_overview/get_transactions_per_minute.ts

@@ -16,15 +16,20 @@ import {
   getDocumentTypeFilterForAggregatedTransactions,
   getProcessorEventForAggregatedTransactions,
 } from '../helpers/aggregated_transactions';
-import { calculateThroughput } from '../helpers/calculate_throughput';
+import {
+  calculateThroughputWithInterval,
+  calculateThroughputWithRange,
+} from '../helpers/calculate_throughput';
 
 export async function getTransactionsPerMinute({
   setup,
   bucketSize,
+  intervalString,
   searchAggregatedTransactions,
 }: {
   setup: Setup & SetupTimeRange;
-  bucketSize: string;
+  bucketSize: number;
+  intervalString: string;
   searchAggregatedTransactions: boolean;
 }) {
   const { apmEventClient, start, end } = setup;
@@ -60,12 +65,9 @@ export async function getTransactionsPerMinute({
               timeseries: {
                 date_histogram: {
                   field: '@timestamp',
-                  fixed_interval: bucketSize,
+                  fixed_interval: intervalString,
                   min_doc_count: 0,
                 },
-                aggs: {
-                  throughput: { rate: { unit: 'minute' as const } },
-                },
               },
             },
           },
@@ -86,15 +88,18 @@ export async function getTransactionsPerMinute({
     ) || aggregations.transactionType.buckets[0];
 
   return {
-    value: calculateThroughput({
+    value: calculateThroughputWithRange({
       start,
       end,
       value: topTransactionTypeBucket?.doc_count || 0,
     }),
     timeseries:
       topTransactionTypeBucket?.timeseries.buckets.map((bucket) => ({
         x: bucket.key,
-        y: bucket.throughput.value,
+        y: calculateThroughputWithInterval({
+          bucketSize,
+          value: bucket.doc_count,
+        }),
       })) || [],
   };
 }

x-pack/plugins/apm/server/lib/service_map/get_service_map_backend_node_info.ts

@@ -16,7 +16,7 @@ import { EventOutcome } from '../../../common/event_outcome';
 import { ProcessorEvent } from '../../../common/processor_event';
 import { environmentQuery } from '../../../common/utils/environment_query';
 import { withApmSpan } from '../../utils/with_apm_span';
-import { calculateThroughput } from '../helpers/calculate_throughput';
+import { calculateThroughputWithRange } from '../helpers/calculate_throughput';
 import { Setup, SetupTimeRange } from '../helpers/setup_request';
 
 interface Options {
@@ -76,7 +76,7 @@ export function getServiceMapBackendNodeInfo({
 
     const avgErrorRate = errorCount / count;
     const avgTransactionDuration = latencySum / count;
-    const avgRequestsPerMinute = calculateThroughput({
+    const avgRequestsPerMinute = calculateThroughputWithRange({
       start,
       end,
       value: count,

x-pack/plugins/apm/server/lib/services/get_service_instances/get_service_instances_transaction_statistics.ts

@@ -20,7 +20,7 @@ import {
   getProcessorEventForAggregatedTransactions,
   getTransactionDurationFieldForAggregatedTransactions,
 } from '../../helpers/aggregated_transactions';
-import { calculateThroughput } from '../../helpers/calculate_throughput';
+import { calculateThroughputWithRange } from '../../helpers/calculate_throughput';
 import { getBucketSizeForAggregatedTransactions } from '../../helpers/get_bucket_size_for_aggregated_transactions';
 import {
   getLatencyAggregation,
@@ -194,7 +194,11 @@ export async function getServiceInstancesTransactionStatistics<
               aggregation: latency,
               latencyAggregationType,
             }),
-            throughput: calculateThroughput({ start, end, value: count }),
+            throughput: calculateThroughputWithRange({
+              start,
+              end,
+              value: count,
+            }),
           };
         }
       }

x-pack/plugins/apm/server/lib/services/get_service_transaction_group_detailed_statistics.ts

@@ -6,6 +6,7 @@
  */
 
 import { keyBy } from 'lodash';
+import { kqlQuery, rangeQuery } from '../../../../observability/server';
 import {
   EVENT_OUTCOME,
   SERVICE_NAME,
@@ -14,9 +15,8 @@ import {
 } from '../../../common/elasticsearch_fieldnames';
 import { EventOutcome } from '../../../common/event_outcome';
 import { LatencyAggregationType } from '../../../common/latency_aggregation_types';
-import { offsetPreviousPeriodCoordinates } from '../../../common/utils/offset_previous_period_coordinate';
-import { kqlQuery, rangeQuery } from '../../../../observability/server';
 import { environmentQuery } from '../../../common/utils/environment_query';
+import { offsetPreviousPeriodCoordinates } from '../../../common/utils/offset_previous_period_coordinate';
 import { Coordinate } from '../../../typings/timeseries';
 import {
   getDocumentTypeFilterForAggregatedTransactions,
@@ -125,11 +125,6 @@ export async function getServiceTransactionGroupDetailedStatistics({
                   },
                 },
                 aggs: {
-                  throughput_rate: {
-                    rate: {
-                      unit: 'minute',
-                    },
-                  },
                   ...getLatencyAggregation(latencyAggregationType, field),
                   [EVENT_OUTCOME]: {
                     terms: {
@@ -160,7 +155,7 @@ export async function getServiceTransactionGroupDetailedStatistics({
     }));
     const throughput = bucket.timeseries.buckets.map((timeseriesBucket) => ({
       x: timeseriesBucket.key,
-      y: timeseriesBucket.throughput_rate.value,
+      y: timeseriesBucket.doc_count, // sparklines only shows trend (no axis)
     }));
     const errorRate = bucket.timeseries.buckets.map((timeseriesBucket) => ({
       x: timeseriesBucket.key,

x-pack/plugins/apm/server/lib/services/get_service_transaction_groups.ts

@@ -20,7 +20,7 @@ import {
   getProcessorEventForAggregatedTransactions,
   getTransactionDurationFieldForAggregatedTransactions,
 } from '../helpers/aggregated_transactions';
-import { calculateThroughput } from '../helpers/calculate_throughput';
+import { calculateThroughputWithRange } from '../helpers/calculate_throughput';
 import {
   getLatencyAggregation,
   getLatencyValue,
@@ -126,7 +126,7 @@ export async function getServiceTransactionGroups({
           latencyAggregationType,
           aggregation: bucket.latency,
         }),
-        throughput: calculateThroughput({
+        throughput: calculateThroughputWithRange({
           start,
           end,
           value: bucket.doc_count,

x-pack/plugins/apm/server/lib/services/get_services/get_service_transaction_stats.ts

@@ -23,7 +23,7 @@ import {
   getProcessorEventForAggregatedTransactions,
   getTransactionDurationFieldForAggregatedTransactions,
 } from '../../helpers/aggregated_transactions';
-import { calculateThroughput } from '../../helpers/calculate_throughput';
+import { calculateThroughputWithRange } from '../../helpers/calculate_throughput';
 import {
   calculateFailedTransactionRate,
   getOutcomeAggregation,
@@ -140,7 +140,7 @@ export async function getServiceTransactionStats({
         transactionErrorRate: calculateFailedTransactionRate(
           topTransactionTypeBucket.outcomes
         ),
-        throughput: calculateThroughput({
+        throughput: calculateThroughputWithRange({
           start,
           end,
           value: topTransactionTypeBucket.doc_count,