[ML] Fetch failed transaction correlations via regular endpoints.

x-pack/plugins/apm/public/components/app/correlations/failed_transactions_correlations.tsx

@@ -36,16 +36,12 @@ import {
 
 import { asPercent } from '../../../../common/utils/formatters';
 import { FailedTransactionsCorrelation } from '../../../../common/search_strategies/failed_transactions_correlations/types';
-import {
-  APM_SEARCH_STRATEGIES,
-  DEFAULT_PERCENTILE_THRESHOLD,
-} from '../../../../common/search_strategies/constants';
+import { DEFAULT_PERCENTILE_THRESHOLD } from '../../../../common/search_strategies/constants';
 import { FieldStats } from '../../../../common/search_strategies/field_stats_types';
 
 import { useApmPluginContext } from '../../../context/apm_plugin/use_apm_plugin_context';
 import { useLocalStorage } from '../../../hooks/useLocalStorage';
 import { FETCH_STATUS } from '../../../hooks/use_fetcher';
-import { useSearchStrategy } from '../../../hooks/use_search_strategy';
 import { useTheme } from '../../../hooks/use_theme';
 
 import { ImpactBar } from '../../shared/ImpactBar';
@@ -68,6 +64,8 @@ import { useTransactionColors } from './use_transaction_colors';
 import { CorrelationsContextPopover } from './context_popover';
 import { OnAddFilter } from './context_popover/top_values';
 
+import { useFailedTransactionsCorrelations } from './use_failed_transactions_correlations';
+
 export function FailedTransactionsCorrelations({
   onFilter,
 }: {
@@ -83,12 +81,8 @@ export function FailedTransactionsCorrelations({
 
   const inspectEnabled = uiSettings.get<boolean>(enableInspectEsQueries);
 
-  const { progress, response, startFetch, cancelFetch } = useSearchStrategy(
-    APM_SEARCH_STRATEGIES.APM_FAILED_TRANSACTIONS_CORRELATIONS,
-    {
-      percentileThreshold: DEFAULT_PERCENTILE_THRESHOLD,
-    }
-  );
+  const { progress, response, startFetch, cancelFetch } =
+    useFailedTransactionsCorrelations();
 
   const fieldStats: Record<string, FieldStats> | undefined = useMemo(() => {
     return response.fieldStats?.reduce((obj, field) => {

x-pack/plugins/apm/public/components/app/correlations/use_failed_transactions_correlations.ts

@@ -0,0 +1,252 @@
+/*
+ * 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 { useCallback, useEffect, useReducer, useRef } from 'react';
+import { chunk } from 'lodash';
+
+import { IHttpFetchError } from 'src/core/public';
+
+import { EVENT_OUTCOME } from '../../../../common/elasticsearch_fieldnames';
+import { EventOutcome } from '../../../../common/event_outcome';
+import { DEFAULT_PERCENTILE_THRESHOLD } from '../../../../common/search_strategies/constants';
+import type { RawResponseBase } from '../../../../common/search_strategies/types';
+import type {
+  FailedTransactionsCorrelation,
+  FailedTransactionsCorrelationsRawResponse,
+} from '../../../../common/search_strategies/failed_transactions_correlations/types';
+
+import { useApmServiceContext } from '../../../context/apm_service/use_apm_service_context';
+import { useUrlParams } from '../../../context/url_params_context/use_url_params';
+
+import { useApmParams } from '../../../hooks/use_apm_params';
+import { useTimeRange } from '../../../hooks/use_time_range';
+import { callApmApi } from '../../../services/rest/createCallApmApi';
+
+type Response = FailedTransactionsCorrelationsRawResponse & RawResponseBase;
+
+interface SearchStrategyProgress {
+  error?: Error | IHttpFetchError;
+  isRunning: boolean;
+  loaded: number;
+  total: number;
+}
+
+const getInitialRawResponse = (): Response =>
+  ({
+    ccsWarning: false,
+    took: 0,
+  } as Response);
+
+const getInitialProgress = (): SearchStrategyProgress => ({
+  isRunning: false,
+  loaded: 0,
+  total: 100,
+});
+
+const getReducer =
+  <T>() =>
+  (prev: T, update: Partial<T>): T => ({
+    ...prev,
+    ...update,
+  });
+
+export function useFailedTransactionsCorrelations() {
+  const { serviceName, transactionType } = useApmServiceContext();
+
+  const { urlParams } = useUrlParams();
+  const { transactionName } = urlParams;
+
+  const {
+    query: { kuery, environment, rangeFrom, rangeTo },
+  } = useApmParams('/services/{serviceName}/transactions/view');
+
+  const { start, end } = useTimeRange({ rangeFrom, rangeTo });
+
+  const [rawResponse, setRawResponse] = useReducer(
+    getReducer<Response>(),
+    getInitialRawResponse()
+  );
+
+  const [fetchState, setFetchState] = useReducer(
+    getReducer<SearchStrategyProgress>(),
+    getInitialProgress()
+  );
+
+  const isCancelledRef = useRef(false);
+
+  const startFetch = useCallback(async () => {
+    isCancelledRef.current = false;
+
+    setFetchState({
+      ...getInitialProgress(),
+      isRunning: true,
+      error: undefined,
+    });
+
+    const query = {
+      serviceName,
+      transactionName,
+      transactionType,
+      kuery,
+      environment,
+      start,
+      end,
+    };
+
+    try {
+      const rawResponseUpdate = (await callApmApi({
+        endpoint: 'POST /internal/apm/latency/overall_distribution',
+        signal: null,
+        params: {
+          body: {
+            ...query,
+            percentileThreshold: DEFAULT_PERCENTILE_THRESHOLD,
+          },
+        },
+      })) as Response;
+
+      const { overallHistogram: errorHistogram } = (await callApmApi({
+        endpoint: 'POST /internal/apm/latency/overall_distribution',
+        signal: null,
+        params: {
+          body: {
+            ...query,
+            percentileThreshold: DEFAULT_PERCENTILE_THRESHOLD,
+            termFilters: [
+              { fieldName: EVENT_OUTCOME, fieldValue: EventOutcome.failure },
+            ],
+          },
+        },
+      })) as Response;
+
+      if (isCancelledRef.current) {
+        return;
+      }
+
+      setRawResponse({
+        ...rawResponseUpdate,
+        errorHistogram,
+      });
+      setFetchState({
+        loaded: 5,
+      });
+
+      const { fieldCandidates: candidates } = await callApmApi({
+        endpoint: 'GET /internal/apm/correlations/field_candidates',
+        signal: null,
+        params: {
+          query,
+        },
+      });
+
+      if (isCancelledRef.current) {
+        return;
+      }
+
+      const fieldCandidates = candidates.filter((t) => !(t === EVENT_OUTCOME));
+
+      setFetchState({
+        loaded: 10,
+      });
+
+      const failedTransactionsCorrelations: FailedTransactionsCorrelation[] =
+        [];
+      const fieldsToSample = new Set<string>();
+      const chunkSize = 10;
+      let loadCounter = 0;
+
+      const fieldCandidatesChunks = chunk(fieldCandidates, chunkSize);
+
+      for (const fieldCandidatesChunk of fieldCandidatesChunks) {
+        const pValues = await callApmApi({
+          endpoint: 'POST /internal/apm/correlations/p_values',
+          signal: null,
+          params: {
+            body: { ...query, fieldCandidates: fieldCandidatesChunk },
+          },
+        });
+
+        if (pValues.failedTransactionsCorrelations.length > 0) {
+          pValues.failedTransactionsCorrelations.forEach((d) => {
+            fieldsToSample.add(d.fieldName);
+          });
+          failedTransactionsCorrelations.push(
+            ...pValues.failedTransactionsCorrelations
+          );
+          rawResponseUpdate.failedTransactionsCorrelations =
+            failedTransactionsCorrelations;
+          setRawResponse(rawResponseUpdate);
+        }
+
+        if (isCancelledRef.current) {
+          return;
+        }
+
+        loadCounter += chunkSize;
+        setFetchState({
+          loaded: 20 + Math.round((loadCounter / fieldCandidates.length) * 80),
+        });
+      }
+
+      const fieldStats = await callApmApi({
+        endpoint: 'POST /internal/apm/correlations/field_stats',
+        signal: null,
+        params: {
+          body: {
+            ...query,
+            fieldsToSample: [...fieldsToSample],
+          },
+        },
+      });
+
+      rawResponseUpdate.fieldStats = fieldStats.stats;
+      setRawResponse(rawResponseUpdate);
+
+      setFetchState({
+        loaded: 100,
+      });
+    } catch (e) {
+      // const err = e as Error | IHttpFetchError;
+      // const message = error.body?.message ?? error.response?.statusText;
+      setFetchState({
+        error: e as Error,
+      });
+    }
+
+    setFetchState({
+      isRunning: false,
+    });
+  }, [
+    environment,
+    serviceName,
+    transactionName,
+    transactionType,
+    kuery,
+    start,
+    end,
+  ]);
+
+  const cancelFetch = useCallback(() => {
+    isCancelledRef.current = true;
+    setFetchState({
+      isRunning: false,
+    });
+  }, []);
+
+  // auto-update
+  useEffect(() => {
+    startFetch();
+    return cancelFetch;
+  }, [startFetch, cancelFetch]);
+
+  return {
+    progress: fetchState,
+    response: rawResponse,
+    startFetch,
+    cancelFetch,
+  };
+}

x-pack/plugins/apm/public/components/app/correlations/use_latency_correlations.ts

@@ -5,7 +5,8 @@
  * 2.0.
  */
 
-import { useCallback, useEffect, useReducer } from 'react';
+import { useCallback, useEffect, useReducer, useRef } from 'react';
+import { chunk } from 'lodash';
 
 import { IHttpFetchError } from 'src/core/public';
 
@@ -73,8 +74,11 @@ export function useLatencyCorrelations() {
     getInitialProgress()
   );
 
+  const isCancelledRef = useRef(false);
+
   const startFetch = useCallback(async () => {
-    // TODO re-implemented cancelling
+    isCancelledRef.current = false;
+
     setFetchState({
       ...getInitialProgress(),
       isRunning: true,
@@ -93,16 +97,20 @@ export function useLatencyCorrelations() {
 
     try {
       const rawResponseUpdate = (await callApmApi({
-        endpoint: 'GET /internal/apm/latency/overall_distribution',
+        endpoint: 'POST /internal/apm/latency/overall_distribution',
         signal: null,
         params: {
-          query: {
+          body: {
             ...query,
             percentileThreshold: DEFAULT_PERCENTILE_THRESHOLD + '',
           },
         },
       })) as Response;
 
+      if (isCancelledRef.current) {
+        return;
+      }
+
       setRawResponse(rawResponseUpdate);
       setFetchState({
         loaded: 5,
@@ -116,6 +124,10 @@ export function useLatencyCorrelations() {
         },
       });
 
+      if (isCancelledRef.current) {
+        return;
+      }
+
       setFetchState({
         loaded: 10,
       });
@@ -130,36 +142,47 @@ export function useLatencyCorrelations() {
           },
         },
       });
+
+      if (isCancelledRef.current) {
+        return;
+      }
+
       setFetchState({
         loaded: 20,
       });
 
       const fieldsToSample = new Set<string>();
       const latencyCorrelations: LatencyCorrelation[] = [];
+      const chunkSize = 10;
       let loadCounter = 0;
-      for (const { fieldName, fieldValue } of fieldValuePairs) {
+
+      const fieldValuePairChunks = chunk(fieldValuePairs, chunkSize);
+
+      for (const fieldValuePairChunk of fieldValuePairChunks) {
         const significantCorrelations = await callApmApi({
-          endpoint: 'GET /internal/apm/correlations/significant_correlations',
+          endpoint: 'POST /internal/apm/correlations/significant_correlations',
           signal: null,
           params: {
-            query: {
-              ...query,
-              fieldName,
-              fieldValue: fieldValue + '',
-            },
+            body: { ...query, fieldValuePairs: fieldValuePairChunk },
           },
         });
 
         if (significantCorrelations.latencyCorrelations.length > 0) {
-          fieldsToSample.add(fieldName);
+          significantCorrelations.latencyCorrelations.forEach((d) => {
+            fieldsToSample.add(d.fieldName);
+          });
           latencyCorrelations.push(
             ...significantCorrelations.latencyCorrelations
           );
           rawResponseUpdate.latencyCorrelations = latencyCorrelations;
           setRawResponse(rawResponseUpdate);
         }
 
-        loadCounter++;
+        if (isCancelledRef.current) {
+          return;
+        }
+
+        loadCounter += chunkSize;
         setFetchState({
           loaded: 20 + Math.round((loadCounter / fieldValuePairs.length) * 80),
         });
@@ -188,7 +211,6 @@ export function useLatencyCorrelations() {
       setFetchState({
         error: e as Error,
       });
-      return;
     }
 
     setFetchState({
@@ -205,6 +227,7 @@ export function useLatencyCorrelations() {
   ]);
 
   const cancelFetch = useCallback(() => {
+    isCancelledRef.current = true;
     setFetchState({
       isRunning: false,
     });

x-pack/plugins/apm/public/hooks/use_latency_overall_distribution.ts

@@ -34,9 +34,9 @@ export function useLatencyOverallDistribution() {
     (callApmApi) => {
       if (serviceName && environment && start && end) {
         return callApmApi({
-          endpoint: 'GET /internal/apm/latency/overall_distribution',
+          endpoint: 'POST /internal/apm/latency/overall_distribution',
           params: {
-            query: {
+            body: {
               serviceName,
               transactionName,
               transactionType,

x-pack/plugins/apm/server/lib/search_strategies/queries/index.ts

@@ -6,6 +6,8 @@
  */
 
 export { fetchFailedTransactionsCorrelationPValues } from './query_failure_correlation';
+export { fetchPValues } from './query_p_values';
+export { fetchSignificantCorrelations } from './query_significant_correlations';
 export { fetchTransactionDurationFieldCandidates } from './query_field_candidates';
 export { fetchTransactionDurationFieldValuePairs } from './query_field_value_pairs';
 export { fetchTransactionDurationFractions } from './query_fractions';

x-pack/plugins/apm/server/lib/search_strategies/queries/query_failure_correlation.ts

@@ -7,6 +7,7 @@
 import { estypes } from '@elastic/elasticsearch';
 import { ElasticsearchClient } from 'kibana/server';
 import { SearchStrategyParams } from '../../../../common/search_strategies/types';
+import { FailedTransactionsCorrelation } from '../../../../common/search_strategies/failed_transactions_correlations/types';
 import { EVENT_OUTCOME } from '../../../../common/elasticsearch_fieldnames';
 import { EventOutcome } from '../../../../common/event_outcome';
 import { fetchTransactionDurationRanges } from './query_ranges';
@@ -88,7 +89,7 @@ export const fetchFailedTransactionsCorrelationPValues = async (
   }>;
 
   // Using for of to sequentially augment the results with histogram data.
-  const result = [];
+  const result: FailedTransactionsCorrelation[] = [];
   for (const bucket of overallResult.buckets) {
     // Scale the score into a value from 0 - 1
     // using a concave piecewise linear function in -log(p-value)

x-pack/plugins/apm/server/lib/search_strategies/queries/query_p_values.ts

@@ -0,0 +1,63 @@
+/*
+ * 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 type { ElasticsearchClient } from 'src/core/server';
+
+import type { SearchStrategyParams } from '../../../../common/search_strategies/types';
+import type { FailedTransactionsCorrelation } from '../../../../common/search_strategies/failed_transactions_correlations/types';
+
+import { ERROR_CORRELATION_THRESHOLD } from '../constants';
+
+import {
+  fetchFailedTransactionsCorrelationPValues,
+  fetchTransactionDurationHistogramRangeSteps,
+} from './index';
+
+export const fetchPValues = async (
+  esClient: ElasticsearchClient,
+  paramsWithIndex: SearchStrategyParams,
+  fieldCandidates: string[]
+) => {
+  const failedTransactionsCorrelations: FailedTransactionsCorrelation[] = [];
+
+  const histogramRangeSteps = await fetchTransactionDurationHistogramRangeSteps(
+    esClient,
+    paramsWithIndex
+  );
+
+  const results = await Promise.allSettled(
+    fieldCandidates.map((fieldName) =>
+      fetchFailedTransactionsCorrelationPValues(
+        esClient,
+        paramsWithIndex,
+        histogramRangeSteps,
+        fieldName
+      )
+    )
+  );
+
+  results.forEach((result, idx) => {
+    if (result.status === 'fulfilled') {
+      failedTransactionsCorrelations.push(
+        ...result.value.filter(
+          (record) =>
+            record &&
+            typeof record.pValue === 'number' &&
+            record.pValue < ERROR_CORRELATION_THRESHOLD
+        )
+      );
+    } else {
+      // If one of the fields in the batch had an error
+      // addLogMessage(
+      //   `Error getting error correlation for field ${fieldCandidates[idx]}: ${result.reason}.`
+      // );
+    }
+  });
+
+  // TODO Fix CCS warning
+  return { failedTransactionsCorrelations, ccsWarning: false };
+};

x-pack/plugins/apm/server/lib/search_strategies/queries/query_significant_correlations.ts

@@ -0,0 +1,74 @@
+/*
+ * 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 { range } from 'lodash';
+
+import type { ElasticsearchClient } from 'src/core/server';
+
+import type {
+  FieldValuePair,
+  SearchStrategyParams,
+} from '../../../../common/search_strategies/types';
+import type { LatencyCorrelation } from '../../../../common/search_strategies/latency_correlations/types';
+
+import {
+  fetchTransactionDurationFractions,
+  fetchTransactionDurationHistogramRangeSteps,
+  fetchTransactionDurationHistograms,
+  fetchTransactionDurationPercentiles,
+} from './index';
+import { computeExpectationsAndRanges } from '../utils';
+
+export const fetchSignificantCorrelations = async (
+  esClient: ElasticsearchClient,
+  paramsWithIndex: SearchStrategyParams,
+  fieldValuePairs: FieldValuePair[]
+) => {
+  // Create an array of ranges [2, 4, 6, ..., 98]
+  const percentileAggregationPercents = range(2, 100, 2);
+  const { percentiles: percentilesRecords } =
+    await fetchTransactionDurationPercentiles(
+      esClient,
+      paramsWithIndex,
+      percentileAggregationPercents
+    );
+  const percentiles = Object.values(percentilesRecords);
+
+  const { expectations, ranges } = computeExpectationsAndRanges(percentiles);
+
+  const { fractions, totalDocCount } = await fetchTransactionDurationFractions(
+    esClient,
+    paramsWithIndex,
+    ranges
+  );
+
+  const histogramRangeSteps = await fetchTransactionDurationHistogramRangeSteps(
+    esClient,
+    paramsWithIndex
+  );
+
+  const latencyCorrelations: LatencyCorrelation[] = [];
+
+  for await (const item of fetchTransactionDurationHistograms(
+    esClient,
+    () => {},
+    paramsWithIndex,
+    expectations,
+    ranges,
+    fractions,
+    histogramRangeSteps,
+    totalDocCount,
+    fieldValuePairs
+  )) {
+    if (item !== undefined) {
+      latencyCorrelations.push(item);
+    }
+  }
+
+  // TODO Fix CCS warning
+  return { latencyCorrelations, ccsWarning: false };
+};

x-pack/plugins/apm/server/plugin.ts

@@ -26,7 +26,6 @@ import { registerFleetPolicyCallbacks } from './lib/fleet/register_fleet_policy_
 import { createApmTelemetry } from './lib/apm_telemetry';
 import { createApmEventClient } from './lib/helpers/create_es_client/create_apm_event_client';
 import { getInternalSavedObjectsClient } from './lib/helpers/get_internal_saved_objects_client';
-import { registerSearchStrategies } from './lib/search_strategies';
 import { createApmAgentConfigurationIndex } from './lib/settings/agent_configuration/create_agent_config_index';
 import { getApmIndices } from './lib/settings/apm_indices/get_apm_indices';
 import { createApmCustomLinkIndex } from './lib/settings/custom_link/create_custom_link_index';
@@ -197,25 +196,6 @@ export class APMPlugin
       logger: this.logger,
     });
 
-    // search strategies for async partial search results
-    core.getStartServices().then(([coreStart]) => {
-      (async () => {
-        const savedObjectsClient = new SavedObjectsClient(
-          coreStart.savedObjects.createInternalRepository()
-        );
-
-        const includeFrozen = await coreStart.uiSettings
-          .asScopedToClient(savedObjectsClient)
-          .get(UI_SETTINGS.SEARCH_INCLUDE_FROZEN);
-
-        registerSearchStrategies(
-          plugins.data.search.registerSearchStrategy,
-          boundGetApmIndices,
-          includeFrozen
-        );
-      })();
-    });
-
     core.deprecations.registerDeprecations({
       getDeprecations: getDeprecations({
         cloudSetup: plugins.cloud,

x-pack/plugins/apm/server/routes/correlations.ts

@@ -6,24 +6,17 @@
  */
 
 import * as t from 'io-ts';
-import { range } from 'lodash';
 
-// import { toNumberRt } from '@kbn/io-ts-utils';
-
-import type { FieldValuePair } from '../../common/search_strategies/types';
-import type { LatencyCorrelation } from '../../common/search_strategies/latency_correlations/types';
+import { toNumberRt } from '@kbn/io-ts-utils';
 
 import { setupRequest } from '../lib/helpers/setup_request';
 import {
+  fetchPValues,
+  fetchSignificantCorrelations,
   fetchTransactionDurationFieldCandidates,
   fetchTransactionDurationFieldValuePairs,
-  fetchTransactionDurationFractions,
-  fetchTransactionDurationHistogramRangeSteps,
-  fetchTransactionDurationHistograms,
-  fetchTransactionDurationPercentiles,
 } from '../lib/search_strategies/queries';
 import { fetchFieldsStats } from '../lib/search_strategies/queries/field_stats/get_fields_stats';
-import { computeExpectationsAndRanges } from '../lib/search_strategies/utils';
 
 import { withApmSpan } from '../utils/with_apm_span';
 
@@ -138,9 +131,9 @@ const fieldValuePairsRoute = createApmServerRoute({
 });
 
 const significantCorrelationsRoute = createApmServerRoute({
-  endpoint: 'GET /internal/apm/correlations/significant_correlations',
+  endpoint: 'POST /internal/apm/correlations/significant_correlations',
   params: t.type({
-    query: t.intersection([
+    body: t.intersection([
       t.partial({
         serviceName: t.string,
         transactionName: t.string,
@@ -150,8 +143,12 @@ const significantCorrelationsRoute = createApmServerRoute({
       kueryRt,
       rangeRt,
       t.type({
-        fieldName: t.string, // t.array(t.string),
-        fieldValue: t.string, // t.array(t.union([t.string, toNumberRt])),
+        fieldValuePairs: t.array(
+          t.type({
+            fieldName: t.string,
+            fieldValue: t.union([t.string, toNumberRt]),
+          })
+        ),
       }),
     ]),
   }),
@@ -160,71 +157,63 @@ const significantCorrelationsRoute = createApmServerRoute({
     const { indices } = await setupRequest(resources);
     const esClient = resources.context.core.elasticsearch.client.asCurrentUser;
 
-    const { fieldName, fieldValue, ...params } = resources.params.query;
-    const fieldValuePairs: FieldValuePair[] = [
-      {
-        fieldName,
-        fieldValue,
-      },
-    ];
+    const { fieldValuePairs, ...params } = resources.params.body;
 
     const paramsWithIndex = {
       ...params,
       index: indices.transaction,
     };
 
-    return withApmSpan('get_significant_correlations', async () => {
-      // Create an array of ranges [2, 4, 6, ..., 98]
-      const percentileAggregationPercents = range(2, 100, 2);
-      const { percentiles: percentilesRecords } =
-        await fetchTransactionDurationPercentiles(
+    return withApmSpan(
+      'get_significant_correlations',
+      async () =>
+        await fetchSignificantCorrelations(
           esClient,
           paramsWithIndex,
-          percentileAggregationPercents
-        );
-      const percentiles = Object.values(percentilesRecords);
-
-      const { expectations, ranges } =
-        computeExpectationsAndRanges(percentiles);
+          fieldValuePairs
+        )
+    );
+  },
+});
 
-      const { fractions, totalDocCount } =
-        await fetchTransactionDurationFractions(
-          esClient,
-          paramsWithIndex,
-          ranges
-        );
+const pValuesRoute = createApmServerRoute({
+  endpoint: 'POST /internal/apm/correlations/p_values',
+  params: t.type({
+    body: t.intersection([
+      t.partial({
+        serviceName: t.string,
+        transactionName: t.string,
+        transactionType: t.string,
+      }),
+      environmentRt,
+      kueryRt,
+      rangeRt,
+      t.type({
+        fieldCandidates: t.array(t.string),
+      }),
+    ]),
+  }),
+  options: { tags: ['access:apm'] },
+  handler: async (resources) => {
+    const { indices } = await setupRequest(resources);
+    const esClient = resources.context.core.elasticsearch.client.asCurrentUser;
 
-      const histogramRangeSteps =
-        await fetchTransactionDurationHistogramRangeSteps(
-          esClient,
-          paramsWithIndex
-        );
+    const { fieldCandidates, ...params } = resources.params.body;
 
-      const latencyCorrelations: LatencyCorrelation[] = [];
+    const paramsWithIndex = {
+      ...params,
+      index: indices.transaction,
+    };
 
-      for await (const item of fetchTransactionDurationHistograms(
-        esClient,
-        () => {},
-        paramsWithIndex,
-        expectations,
-        ranges,
-        fractions,
-        histogramRangeSteps,
-        totalDocCount,
-        fieldValuePairs
-      )) {
-        if (item !== undefined) {
-          latencyCorrelations.push(item);
-        }
-      }
-
-      // TODO Fix CCS warning
-      return { latencyCorrelations, ccsWarning: false };
-    });
+    return withApmSpan(
+      'get_p_values',
+      async () => await fetchPValues(esClient, paramsWithIndex, fieldCandidates)
+    );
   },
 });
 
 export const correlationsRouteRepository = createApmServerRouteRepository()
+  .add(pValuesRoute)
   .add(fieldCandidatesRoute)
   .add(fieldStatsRoute)
   .add(fieldValuePairsRoute)