[APM] Include services with only metric documents

Closes #92075.

x-pack/plugins/apm/common/utils/as_mutable_array.ts

@@ -0,0 +1,12 @@
+/*
+ * 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.
+ */
+
+export function asMutableArray<T extends Readonly<any>>(
+  arr: T
+): T extends Readonly<[...infer U]> ? U : unknown[] {
+  return arr as any;
+}

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

@@ -35,14 +35,14 @@ interface AggregationParams {
   environment?: string;
   setup: ServicesItemsSetup;
   searchAggregatedTransactions: boolean;
+  maxNumServices: number;
 }
 
-const MAX_NUMBER_OF_SERVICES = 500;
-
 export async function getServiceTransactionStats({
   environment,
   setup,
   searchAggregatedTransactions,
+  maxNumServices,
 }: AggregationParams) {
   return withApmSpan('get_service_transaction_stats', async () => {
     const { apmEventClient, start, end, esFilter } = setup;
@@ -86,7 +86,7 @@ export async function getServiceTransactionStats({
           services: {
             terms: {
               field: SERVICE_NAME,
-              size: MAX_NUMBER_OF_SERVICES,
+              size: maxNumServices,
             },
             aggs: {
               transactionType: {
@@ -98,7 +98,6 @@ export async function getServiceTransactionStats({
                   environments: {
                     terms: {
                       field: SERVICE_ENVIRONMENT,
-                      missing: '',
                     },
                   },
                   sample: {
@@ -141,9 +140,9 @@ export async function getServiceTransactionStats({
         return {
           serviceName: bucket.key as string,
           transactionType: topTransactionTypeBucket.key as string,
-          environments: topTransactionTypeBucket.environments.buckets
-            .map((environmentBucket) => environmentBucket.key as string)
-            .filter(Boolean),
+          environments: topTransactionTypeBucket.environments.buckets.map(
+            (environmentBucket) => environmentBucket.key as string
+          ),
           agentName: topTransactionTypeBucket.sample.top[0].metrics[
             AGENT_NAME
           ] as AgentName,

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

@@ -0,0 +1,82 @@
+/*
+ * 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 { AgentName } from '../../../../typings/es_schemas/ui/fields/agent';
+import {
+  AGENT_NAME,
+  SERVICE_ENVIRONMENT,
+  SERVICE_NAME,
+} from '../../../../common/elasticsearch_fieldnames';
+import { environmentQuery, rangeQuery } from '../../../../common/utils/queries';
+import { ProcessorEvent } from '../../../../common/processor_event';
+import { Setup, SetupTimeRange } from '../../helpers/setup_request';
+import { withApmSpan } from '../../../utils/with_apm_span';
+
+export function getServicesFromMetricDocuments({
+  environment,
+  setup,
+  maxNumServices,
+}: {
+  setup: Setup & SetupTimeRange;
+  environment?: string;
+  maxNumServices: number;
+}) {
+  return withApmSpan('get_services_from_metric_documents', async () => {
+    const { apmEventClient, start, end, esFilter } = setup;
+
+    const response = await apmEventClient.search({
+      apm: {
+        events: [ProcessorEvent.metric],
+      },
+      body: {
+        size: 0,
+        query: {
+          bool: {
+            filter: [
+              ...rangeQuery(start, end),
+              ...environmentQuery(environment),
+              ...esFilter,
+            ],
+          },
+        },
+        aggs: {
+          services: {
+            terms: {
+              field: SERVICE_NAME,
+              size: maxNumServices,
+            },
+            aggs: {
+              environments: {
+                terms: {
+                  field: SERVICE_ENVIRONMENT,
+                },
+              },
+              latest: {
+                top_metrics: {
+                  metrics: { field: AGENT_NAME } as const,
+                  sort: { '@timestamp': 'desc' },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    return (
+      response.aggregations?.services.buckets.map((bucket) => {
+        return {
+          serviceName: bucket.key as string,
+          environments: bucket.environments.buckets.map(
+            (envBucket) => envBucket.key as string
+          ),
+          agentName: bucket.latest.top[0].metrics[AGENT_NAME] as AgentName,
+        };
+      }) ?? []
+    );
+  });
+}

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

@@ -6,15 +6,18 @@
  */
 
 import { Logger } from '@kbn/logging';
+import { asMutableArray } from '../../../../common/utils/as_mutable_array';
 import { joinByKey } from '../../../../common/utils/join_by_key';
-import { getServicesProjection } from '../../../projections/services';
 import { withApmSpan } from '../../../utils/with_apm_span';
 import { Setup, SetupTimeRange } from '../../helpers/setup_request';
 import { getHealthStatuses } from './get_health_statuses';
+import { getServicesFromMetricDocuments } from './get_services_from_metric_documents';
 import { getServiceTransactionStats } from './get_service_transaction_stats';
 
 export type ServicesItemsSetup = Setup & SetupTimeRange;
 
+const MAX_NUMBER_OF_SERVICES = 500;
+
 export async function getServicesItems({
   environment,
   setup,
@@ -29,32 +32,49 @@ export async function getServicesItems({
   return withApmSpan('get_services_items', async () => {
     const params = {
       environment,
-      projection: getServicesProjection({
-        setup,
-        searchAggregatedTransactions,
-      }),
       setup,
       searchAggregatedTransactions,
+      maxNumServices: MAX_NUMBER_OF_SERVICES,
     };
 
-    const [transactionStats, healthStatuses] = await Promise.all([
+    const [
+      transactionStats,
+      servicesFromMetricDocuments,
+      healthStatuses,
+    ] = await Promise.all([
       getServiceTransactionStats(params),
+      getServicesFromMetricDocuments(params),
       getHealthStatuses(params).catch((err) => {
         logger.error(err);
         return [];
       }),
     ]);
 
-    const apmServices = transactionStats.map(({ serviceName }) => serviceName);
+    const foundServiceNames = transactionStats.map(
+      ({ serviceName }) => serviceName
+    );
+
+    const servicesWithOnlyMetricDocuments = servicesFromMetricDocuments.filter(
+      ({ serviceName }) => !foundServiceNames.includes(serviceName)
+    );
+
+    const allServiceNames = foundServiceNames.concat(
+      servicesWithOnlyMetricDocuments.map(({ serviceName }) => serviceName)
+    );
 
     // make sure to exclude health statuses from services
     // that are not found in APM data
     const matchedHealthStatuses = healthStatuses.filter(({ serviceName }) =>
-      apmServices.includes(serviceName)
+      allServiceNames.includes(serviceName)
     );
 
-    const allMetrics = [...transactionStats, ...matchedHealthStatuses];
-
-    return joinByKey(allMetrics, 'serviceName');
+    return joinByKey(
+      asMutableArray([
+        ...transactionStats,
+        ...servicesWithOnlyMetricDocuments,
+        ...matchedHealthStatuses,
+      ] as const),
+      'serviceName'
+    );
   });
 }

x-pack/test/apm_api_integration/tests/services/top_services.ts

@@ -261,6 +261,51 @@ export default function ApiTest({ getService }: FtrProviderContext) {
     }
   );
 
+  registry.when(
+    'APM Services Overview with a basic license when data is loaded excluding transaction events',
+    { config: 'basic', archives: [archiveName] },
+    () => {
+      it('includes services that only report metric data', async () => {
+        interface Response {
+          status: number;
+          body: APIReturnType<'GET /api/apm/services'>;
+        }
+
+        const [unfilteredResponse, filteredResponse] = await Promise.all([
+          supertest.get(
+            `/api/apm/services?start=${start}&end=${end}&uiFilters={}`
+          ) as Promise<Response>,
+          supertest.get(
+            `/api/apm/services?start=${start}&end=${end}&uiFilters=${encodeURIComponent(
+              `{ "kuery": "not (processor.event:transaction)" }`
+            )}`
+          ) as Promise<Response>,
+        ]);
+
+        expect(unfilteredResponse.body.items.length).to.be.greaterThan(0);
+
+        const unfilteredServiceNames = unfilteredResponse.body.items
+          .map((item) => item.serviceName)
+          .sort();
+
+        const filteredServiceNames = filteredResponse.body.items
+          .map((item) => item.serviceName)
+          .sort();
+
+        expect(unfilteredServiceNames).to.eql(filteredServiceNames);
+
+        expect(
+          filteredResponse.body.items.every((item) => {
+            // make sure it did not query transaction data
+            return isEmpty(item.avgResponseTime);
+          })
+        ).to.be(true);
+
+        expect(filteredResponse.body.items.every((item) => !!item.agentName)).to.be(true);
+      });
+    }
+  );
+
   registry.when(
     'APM Services overview with a trial license when data is loaded',
     { config: 'trial', archives: [archiveName] },