combine service map queries (#2367)

Signed-off-by: Adam Tackett <[email protected]>
Co-authored-by: Adam Tackett <[email protected]>
(cherry picked from commit 5cfe888)
Signed-off-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: github-actions[bot]

public/components/trace_analytics/requests/queries/services_queries.ts

@@ -90,46 +90,7 @@ export const getServicesQuery = (
   return query;
 };
 
-export const getRelatedServicesQuery = (serviceName: string) => {
-  const query = {
-    size: 0,
-    query: {
-      bool: {
-        must: [],
-        filter: [],
-        should: [],
-        must_not: [],
-      },
-    },
-    aggs: {
-      traces: {
-        terms: {
-          field: 'traceId',
-          size: 10000,
-        },
-        aggs: {
-          service: {
-            filter: {
-              bool: {
-                must: [
-                  {
-                    term: {
-                      serviceName,
-                    },
-                  },
-                ],
-                must_not: [],
-              },
-            },
-          },
-        },
-      },
-    },
-  };
-  return query;
-};
-
-export const getServiceNodesQuery = (mode: TraceAnalyticsMode) => {
+export const getServiceMapQuery = (mode: TraceAnalyticsMode) => {
   return {
     index: getServiceIndices(mode),
     size: 0,
@@ -154,43 +115,41 @@ export const getServiceNodesQuery = (mode: TraceAnalyticsMode) => {
               size: SERVICE_MAP_MAX_EDGES,
             },
           },
-        },
-      },
-    },
-  };
-};
-
-export const getServiceEdgesQuery = (
-  source: 'destination' | 'target',
-  mode: TraceAnalyticsMode
-) => {
-  return {
-    index: getServiceIndices(mode),
-    size: 0,
-    query: {
-      bool: {
-        must: [],
-        filter: [],
-        should: [],
-        must_not: [],
-      },
-    },
-    aggs: {
-      service_name: {
-        terms: {
-          field: 'serviceName',
-          size: SERVICE_MAP_MAX_EDGES,
-        },
-        aggs: {
-          resource: {
+          target_edges: {
+            terms: {
+              field: 'target.resource',
+              size: SERVICE_MAP_MAX_EDGES,
+            },
+            aggs: {
+              service: {
+                terms: {
+                  field: 'target.serviceName',
+                  size: SERVICE_MAP_MAX_EDGES,
+                },
+              },
+              domain: {
+                terms: {
+                  field: 'target.domain',
+                  size: SERVICE_MAP_MAX_EDGES,
+                },
+              },
+            },
+          },
+          destination_edges: {
             terms: {
-              field: `${source}.resource`,
+              field: 'destination.resource',
               size: SERVICE_MAP_MAX_EDGES,
             },
             aggs: {
+              service: {
+                terms: {
+                  field: 'destination.serviceName',
+                  size: SERVICE_MAP_MAX_EDGES,
+                },
+              },
               domain: {
                 terms: {
-                  field: `${source}.domain`,
+                  field: 'destination.domain',
                   size: SERVICE_MAP_MAX_EDGES,
                 },
               },

public/components/trace_analytics/requests/services_request_handler.ts

@@ -15,9 +15,8 @@ import { coreRefs } from '../../../../public/framework/core_refs';
 import { fixedIntervalToMilli } from '../components/common/helper_functions';
 import { ServiceObject } from '../components/common/plots/service_map';
 import {
-  getServiceEdgesQuery,
+  getServiceMapQuery,
   getServiceMetricsQuery,
-  getServiceNodesQuery,
   getServicesQuery,
   getServiceTrendsQuery,
 } from './queries/services_queries';
@@ -103,10 +102,10 @@ export const handleServiceMapRequest = async (
   }
   const map: ServiceObject = {};
   let id = 1;
-  const serviceNodesResponse = await handleDslRequest(
+  const serviceMapResponse = await handleDslRequest(
     http,
     null,
-    getServiceNodesQuery(mode),
+    getServiceMapQuery(mode),
     mode,
     dataSourceMDSId
   ).catch((error) => {
@@ -119,70 +118,72 @@ export const handleServiceMapRequest = async (
   });
 
   if (
-    !serviceNodesResponse ||
-    !serviceNodesResponse.aggregations ||
-    !serviceNodesResponse.aggregations.service_name ||
-    !serviceNodesResponse.aggregations.service_name.buckets ||
-    serviceNodesResponse.aggregations.service_name.buckets.length === 0
+    !serviceMapResponse ||
+    !serviceMapResponse.aggregations ||
+    !serviceMapResponse.aggregations.service_name ||
+    !serviceMapResponse.aggregations.service_name.buckets ||
+    serviceMapResponse.aggregations.service_name.buckets.length === 0
   ) {
     if (setItems) {
       setItems(map);
     }
     return map;
   }
 
-  serviceNodesResponse.aggregations.service_name.buckets.forEach((bucket: any) => {
-    map[bucket.key] = {
-      serviceName: bucket.key,
+  const targets: Record<string, string> = {};
+
+  serviceMapResponse.aggregations.service_name.buckets.forEach((bucket: any) => {
+    const serviceName = bucket.key;
+    map[serviceName] = {
+      serviceName,
       id: id++,
       targetResources: bucket.target_resource.buckets.map((res: any) => res.key),
       targetServices: [],
       destServices: [],
     };
   });
 
-  const targets: Record<string, string> = {};
-  await handleDslRequest(http, null, getServiceEdgesQuery('target', mode), mode, dataSourceMDSId)
-    .then((response) =>
-      response.aggregations.service_name.buckets.map((bucket: any) => {
-        bucket.resource.buckets.map((resource: any) => {
-          resource.domain.buckets.map((domain: any) => {
-            targets[resource.key + ':' + domain.key] = bucket.key;
-          });
-        });
-      })
-    )
-    .catch((error) => {
-      console.error('Error retrieving target edges:', error);
+  serviceMapResponse.aggregations.service_name.buckets.forEach((bucket: any) => {
+    const serviceName = bucket.key;
+
+    bucket.target_edges?.buckets.forEach((resource: any) => {
+      resource.domain?.buckets.forEach((domain: any) => {
+        const key = `${resource.key}:${domain.key}`;
+        targets[key] = serviceName;
+      });
     });
+  });
 
-  await handleDslRequest(
-    http,
-    null,
-    getServiceEdgesQuery('destination', mode),
-    mode,
-    dataSourceMDSId
-  )
-    .then((response) =>
-      Promise.all(
-        response.aggregations.service_name.buckets.map((bucket: any) => {
-          bucket.resource.buckets.map((resource: any) => {
-            resource.domain.buckets.map((domain: any) => {
-              const targetService = targets[resource.key + ':' + domain.key];
-              if (targetService) {
-                if (map[bucket.key].targetServices.indexOf(targetService) === -1)
-                  map[bucket.key].targetServices.push(targetService);
-                if (map[targetService].destServices.indexOf(bucket.key) === -1)
-                  map[targetService].destServices.push(bucket.key);
-              }
-            });
-          });
-        })
-      )
-    )
-    .catch((error) => {
-      console.error('Error retrieving destination edges:', error);
+  serviceMapResponse.aggregations.service_name.buckets.forEach((bucket: any) => {
+    const serviceName = bucket.key;
+
+    bucket.destination_edges?.buckets.forEach((resource: any) => {
+      resource.domain?.buckets.forEach((domain: any) => {
+        const key = `${resource.key}:${domain.key}`;
+        const targetService = targets[key];
+
+        if (targetService) {
+          if (!map[targetService]) {
+            map[targetService] = {
+              serviceName: targetService,
+              id: id++,
+              targetResources: [],
+              targetServices: [],
+              destServices: [],
+            };
+          }
+
+          if (!map[serviceName].targetServices.includes(targetService)) {
+            map[serviceName].targetServices.push(targetService);
+          }
+
+          if (!map[targetService].destServices.includes(serviceName)) {
+            map[targetService].destServices.push(serviceName);
+          }
+        }
+      });
     });
+  });
 
   if (includeMetrics) {
     try {