[performance] exclude ES request body when polling (#237191)

## Summary

Close #186138

### Background

This reduces the network overhead between Kibana client and server. It
leaves out the request body when polling an already-executed search.

After the initial search request, there is only one reason the server
has needed the request body: to associate the request with a background
search session. Previously, this was done by computing a hash of the
request body server-side. Now, the hash is computed on the client and
transmitted _in lieu_ of the request body.

For some legacy visualizations (TSVB and Timeline) which build the DSL
request server-side, responsibility to provide the request hash has
moved to their code bases since the session service no longer does this
internally.

#### Note on existing saved searches

The hashing algorithm used on the frontend is identical to what was used
on the backend, meaning that requests will still match any pre-existing
saved searches they did before. (I checked during development, but might
be worth a final test.)

### Impact

To get a sense for the reduction, I pulled a few examples of the polling
request body from the flights dashboard.

| Request | Size (main) | Size (this branch) | % Reduction |
|----------|--------------|--------------------|--------------|
| 1 | 1219 | 378 | 70% |
| 2 | 744 | 255 | 66% |
| 3 | 1083 | 333 | 70% |
| 4 | 884 | 333 | 62% |

The change appears to reduce the polling payload size by roughly
**60-70%**! (Only tested on DSL-powered panels.)

---------

Co-authored-by: Elastic Machine <[email protected]>
Co-authored-by: kibanamachine <[email protected]>
Co-authored-by: Lukas Olson <[email protected]>

Author: 4 people

src/platform/packages/shared/kbn-search-types/src/types.ts

@@ -119,6 +119,11 @@ export interface ISearchOptions {
    * When set es results are streamed back to the caller without any parsing of the content.
    */
   stream?: boolean;
+
+  /**
+   * A hash of the request params. This is attached automatically by the search interceptor. It is used to link this request with a search session.
+   */
+  requestHash?: string;
 }
 
 /**

src/platform/plugins/private/vis_types/timelion/server/series_functions/es/index.js

@@ -12,6 +12,7 @@ import _ from 'lodash';
 import Datasource from '../../lib/classes/datasource';
 import buildRequest from './lib/build_request';
 import toSeriesList from './lib/agg_response_to_series_list';
+import { createRequestHash } from '@kbn/vis-type-timeseries-plugin/server';
 
 function getRequestAbortedSignal(aborted$) {
   const controller = new AbortController();
@@ -127,11 +128,13 @@ export default new Datasource('es', {
     const abortSignal = getRequestAbortedSignal(tlConfig.request.events.aborted$);
 
     const searchContext = await tlConfig.context.search;
+    const requestHash = createRequestHash(body.params);
     const resp = await searchContext
       .search(
         body,
         {
           ...tlConfig.request?.body.searchSession,
+          requestHash,
         },
         { ...tlConfig.context, abortSignal }
       )

src/platform/plugins/private/vis_types/timelion/tsconfig.json

@@ -36,6 +36,7 @@
     "@kbn/react-kibana-context-render",
     "@kbn/css-utils",
     "@kbn/visualizations-common",
+    "@kbn/vis-type-timeseries-plugin",
   ],
   "exclude": [
     "target/**/*",

src/platform/plugins/shared/data/server/search/session/utils.test.ts renamed to src/platform/plugins/shared/data/public/search/search_interceptor/create_request_hash.test.ts

@@ -7,21 +7,18 @@
  * License v3.0 only", or the "Server Side Public License, v 1".
  */
 
-import { createRequestHash } from './utils';
+import { createRequestHash } from './create_request_hash';
 
-describe('data/search/session utils', () => {
-  describe('createRequestHash', () => {
-    it('ignores `preference`', () => {
-      const request = {
-        foo: 'bar',
-      };
+describe('createRequestHash', () => {
+  it('ignores `preference`', () => {
+    const request = {
+      foo: 'bar',
+    };
+    const withPreference = {
+      ...request,
+      preference: 1234,
+    };
 
-      const withPreference = {
-        ...request,
-        preference: 1234,
-      };
-
-      expect(createRequestHash(request)).toEqual(createRequestHash(withPreference));
-    });
+    expect(createRequestHash(request)).toEqual(createRequestHash(withPreference));
   });
 });

src/platform/plugins/shared/data/public/search/search_interceptor/create_request_hash.ts

@@ -10,6 +10,15 @@
 import { Sha256 } from '@kbn/crypto-browser';
 import stringify from 'json-stable-stringify';
 
-export async function createRequestHash(keys: Record<string, any>) {
-  return new Sha256().update(stringify(keys), 'utf8').digest('hex');
+/**
+ * Generate the hash for this request. Ignores the `preference` parameter since it generally won't
+ * match from one request to another identical request.
+ *
+ * (Preference is used to ensure all queries go to the same set of shards and it doesn't need to be hashed
+ * https://www.elastic.co/guide/en/elasticsearch/reference/current/search-shard-routing.html#shard-and-node-preference)
+ */
+export function createRequestHash(keys: Record<string, any>) {
+  const { preference, ...params } = keys;
+  const hash = new Sha256().update(stringify(params), 'utf8').digest('hex');
+  return hash;
 }

src/platform/plugins/shared/data/public/search/search_interceptor/search_interceptor.test.ts

@@ -35,7 +35,8 @@ jest.mock('./create_request_hash', () => {
   return {
     ...originalModule,
     createRequestHash: jest.fn().mockImplementation((input) => {
-      return Promise.resolve(JSON.stringify(input));
+      const { preference, ...params } = input;
+      return JSON.stringify(params);
     }),
   };
 });
@@ -319,7 +320,14 @@ describe('SearchInterceptor', () => {
 
       mockCoreSetup.http.post.mockImplementation(getHttpMock(responses));
 
-      const response = searchInterceptor.search({}, { pollInterval: 0 });
+      const response = searchInterceptor.search(
+        {
+          params: {
+            body: { query: { match_all: {} } },
+          },
+        },
+        { pollInterval: 0 }
+      );
       response.subscribe({ next, error, complete });
 
       await timeTravel(10);
@@ -387,6 +395,18 @@ describe('SearchInterceptor', () => {
       `);
       expect(complete).toHaveBeenCalled();
       expect(error).not.toHaveBeenCalled();
+
+      // check that the request body wasn't included on the 2nd request
+      expect(mockCoreSetup.http.post).toHaveBeenCalledTimes(2);
+      const firstRequest = (
+        mockCoreSetup.http.post.mock.calls[0] as unknown as [string, HttpFetchOptions]
+      )[1];
+      expect(JSON.parse(firstRequest?.body as string).params.body).toBeDefined();
+
+      const secondRequest = (
+        mockCoreSetup.http.post.mock.calls[1] as unknown as [string, HttpFetchOptions]
+      )[1];
+      expect(JSON.parse(secondRequest?.body as string).params.body).not.toBeDefined();
     });
 
     test('should abort on user abort', async () => {

src/platform/plugins/shared/data/public/search/search_interceptor/search_interceptor.ts

@@ -173,19 +173,14 @@ export class SearchInterceptor {
     options: IAsyncSearchOptions
   ): Observable<string | undefined> {
     const { sessionId } = options;
-    // Preference is used to ensure all queries go to the same set of shards and it doesn't need to be hashed
-    // https://www.elastic.co/guide/en/elasticsearch/reference/current/search-shard-routing.html#shard-and-node-preference
-    const { preference, ...params } = request.params || {};
     const hashOptions = {
-      ...params,
+      ...request.params,
       sessionId,
     };
 
     if (!sessionId) return of(undefined); // don't use cache if doesn't belong to a session
-    const sessionOptions = this.deps.session.getSearchOptions(options.sessionId);
-    if (sessionOptions?.isRestore) return of(undefined); // don't use cache if restoring a session
 
-    return from(createRequestHash(hashOptions));
+    return from(Promise.resolve(createRequestHash(hashOptions)));
   }
 
   /*
@@ -447,7 +442,20 @@ export class SearchInterceptor {
     request: IKibanaSearchRequest,
     options?: ISearchOptions
   ): Promise<IKibanaSearchResponse> {
-    const { abortSignal } = options || {};
+    const { abortSignal, requestHash } = options || {};
+
+    if (request.id) {
+      // just polling an existing search, no need to send the body, just the hash
+
+      const { params, ...requestWithoutParams } = request;
+      if (params) {
+        const { body, ...paramsWithoutBody } = params;
+        request = {
+          ...requestWithoutParams,
+          params: paramsWithoutBody,
+        };
+      }
+    }
 
     const { executionContext, strategy, ...searchOptions } = this.getSerializableOptions(options);
     return this.deps.http
@@ -460,6 +468,7 @@ export class SearchInterceptor {
           body: JSON.stringify({
             ...request,
             ...searchOptions,
+            requestHash,
             stream:
               strategy === ESQL_ASYNC_SEARCH_STRATEGY ||
               strategy === ENHANCED_ES_SEARCH_STRATEGY ||
@@ -537,12 +546,11 @@ export class SearchInterceptor {
    * Creates a new search observable and a corresponding search abort controller
    * If requestHash is defined, tries to return them first from cache.
    */
-  private getSearchResponse$(
-    request: IKibanaSearchRequest,
-    options: IAsyncSearchOptions,
-    requestHash?: string
-  ) {
-    const cached = requestHash ? this.responseCache.get(requestHash) : undefined;
+  private getSearchResponse$(request: IKibanaSearchRequest, options: IAsyncSearchOptions) {
+    const { requestHash } = options;
+    const sessionOptions = this.deps.session.getSearchOptions(options.sessionId);
+    const cached =
+      requestHash && !sessionOptions?.isRestore ? this.responseCache.get(requestHash) : undefined; // don't use cache if restoring a session
 
     const searchAbortController =
       cached?.searchAbortController || new SearchAbortController(this.searchTimeout);
@@ -586,10 +594,10 @@ export class SearchInterceptor {
 
     return this.createRequestHash$(request, searchOptions).pipe(
       switchMap((requestHash) => {
+        searchOptions.requestHash = requestHash;
         const { searchAbortController, response$ } = this.getSearchResponse$(
           request,
-          searchOptions,
-          requestHash
+          searchOptions
         );
 
         this.pendingCount$.next(this.pendingCount$.getValue() + 1);

src/platform/plugins/shared/data/server/search/routes/search.ts

@@ -54,6 +54,7 @@ export function registerSearchRoute(
                 isRestore: schema.maybe(schema.boolean()),
                 retrieveResults: schema.maybe(schema.boolean()),
                 stream: schema.maybe(schema.boolean()),
+                requestHash: schema.maybe(schema.string()),
               },
               { unknowns: 'allow' }
             ),
@@ -68,6 +69,7 @@ export function registerSearchRoute(
           isRestore,
           retrieveResults,
           stream,
+          requestHash,
           ...searchRequest
         } = request.body;
         const { strategy, id } = request.params;
@@ -101,6 +103,7 @@ export function registerSearchRoute(
                   isRestore,
                   retrieveResults,
                   stream,
+                  requestHash,
                 }
               )
               .pipe(first())

src/platform/plugins/shared/data/server/search/search_service.test.ts

@@ -247,7 +247,7 @@ describe('Search service', () => {
 
         expect(mockSessionClient.trackId).toBeCalledTimes(1);
 
-        expect(mockSessionClient.trackId.mock.calls[0]).toEqual([searchRequest, 'my_id', options]);
+        expect(mockSessionClient.trackId.mock.calls[0]).toEqual(['my_id', options]);
       });
 
       it('does not call `trackId` if search is already tracked', async () => {

src/platform/plugins/shared/data/server/search/search_service.ts

@@ -410,9 +410,7 @@ export class SearchService {
                     isStored: true,
                   });
                 } else {
-                  return from(
-                    deps.searchSessionsClient.trackId(request, response.id, options)
-                  ).pipe(
+                  return from(deps.searchSessionsClient.trackId(response.id, options)).pipe(
                     tap(() => {
                       isInternalSearchStored = true;
                     }),