[Search Sessions] Save all sessions, with persisted flag

src/plugins/data/common/utils/index.ts

@@ -8,4 +8,3 @@
 
 /** @internal */
 export { shortenDottedString } from './shorten_dotted_string';
-export { tapFirst } from './tap_first';

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

@@ -17,6 +17,18 @@ import { createIndexPatternsStartMock } from '../index_patterns/mocks';
 import { SearchService, SearchServiceSetupDependencies } from './search_service';
 import { bfetchPluginMock } from '../../../bfetch/server/mocks';
 import { of } from 'rxjs';
+import {
+ IEsSearchRequest,
+ IEsSearchResponse,
+ IScopedSearchClient,
+ IScopedSearchSessionsClient,
+ ISearchSessionService,
+ ISearchStart,
+ ISearchStrategy,
+} from '.';
+// eslint-disable-next-line @kbn/eslint/no-restricted-paths
+import { expressionsPluginMock } from '../../../expressions/public/mocks';
+import { createSearchSessionsClientMock } from './mocks';
 
 describe('Search service', () => {
  let plugin: SearchService;
@@ -70,4 +82,136 @@ describe('Search service', () => {
  expect(start).toHaveProperty('getSearchStrategy');
  });
  });
+
+ describe('asScopedProvider', () => {
+ let mockScopedClient: IScopedSearchClient;
+ let searcPluginStart: ISearchStart<IEsSearchRequest, IEsSearchResponse<any>>;
+ let mockStrategy: jest.Mocked<ISearchStrategy>;
+ let mockSessionService: ISearchSessionService<any>;
+ let mockSessionClient: jest.Mocked<IScopedSearchSessionsClient>;
+ const sessionId = '1234';
+
+ beforeEach(() => {
+ mockStrategy = { search: jest.fn().mockReturnValue(of({})) };
+
+ mockSessionClient = createSearchSessionsClientMock();
+ mockSessionService = {
+ asScopedProvider: () => (request: any) => mockSessionClient,
+ };
+
+ const pluginSetup = plugin.setup(mockCoreSetup, {
+ bfetch: bfetchPluginMock.createSetupContract(),
+ expressions: expressionsPluginMock.createSetupContract(),
+ });
+ pluginSetup.registerSearchStrategy('es', mockStrategy);
+ pluginSetup.__enhance({
+ defaultStrategy: 'es',
+ sessionService: mockSessionService,
+ });
+
+ searcPluginStart = plugin.start(mockCoreStart, {
+ fieldFormats: createFieldFormatsStartMock(),
+ indexPatterns: createIndexPatternsStartMock(),
+ });
+
+ const r: any = {};
+
+ mockScopedClient = searcPluginStart.asScoped(r);
+ });
+
+ describe('search', () => {
+ it('searches using the original request if not restoring, trackId is not called if there is no id in the response', async () => {
+ const searchRequest = { params: {} };
+ const options = { sessionId, isStored: false, isRestore: false };
+ mockSessionClient.trackId = jest.fn();
+
+ mockStrategy.search.mockReturnValue(
+ of({
+ rawResponse: {} as any,
+ })
+ );
+
+ await mockScopedClient.search(searchRequest, options).toPromise();
+
+ const [request, callOptions] = mockStrategy.search.mock.calls[0];
+
+ expect(callOptions).toBe(options);
+ expect(request).toBe(searchRequest);
+ expect(mockSessionClient.trackId).not.toBeCalled();
+ });
+
+ it('searches using the original request if `id` is provided', async () => {
+ const searchId = 'FnpFYlBpeXdCUTMyZXhCLTc1TWFKX0EbdDFDTzJzTE1Sck9PVTBIcW1iU05CZzo4MDA0';
+ const searchRequest = { id: searchId, params: {} };
+ const options = { sessionId, isStored: true, isRestore: true };
+
+ await mockScopedClient.search(searchRequest, options).toPromise();
+
+ const [request, callOptions] = mockStrategy.search.mock.calls[0];
+ expect(callOptions).toBe(options);
+ expect(request).toBe(searchRequest);
+ });
+
+ it('searches by looking up an `id` if restoring and `id` is not provided', async () => {
+ const searchRequest = { params: {} };
+ const options = { sessionId, isStored: true, isRestore: true };
+
+ mockSessionClient.getId = jest.fn().mockResolvedValueOnce('my_id');
+
+ await mockScopedClient.search(searchRequest, options).toPromise();
+
+ const [request, callOptions] = mockStrategy.search.mock.calls[0];
+ expect(callOptions).toBe(options);
+ expect(request).toStrictEqual({ ...searchRequest, id: 'my_id' });
+ });
+
+ it('calls `trackId` for every response, if the response contains an `id` and not restoring', async () => {
+ const searchRequest = { params: {} };
+ const options = { sessionId, isStored: false, isRestore: false };
+ mockSessionClient.trackId = jest.fn();
+
+ mockStrategy.search.mockReturnValue(
+ of(
+ {
+ id: 'my_id',
+ rawResponse: {} as any,
+ },
+ {
+ id: 'my_id',
+ rawResponse: {} as any,
+ }
+ )
+ );
+
+ await mockScopedClient.search(searchRequest, options).toPromise();
+
+ expect(mockSessionClient.trackId).toBeCalledTimes(2);
+
+ expect(mockSessionClient.trackId.mock.calls[0]).toEqual([searchRequest, 'my_id', options]);
+ expect(mockSessionClient.trackId.mock.calls[1]).toEqual([searchRequest, 'my_id', options]);
+ });
+
+ it('does not call `trackId` if restoring', async () => {
+ const searchRequest = { params: {} };
+ const options = { sessionId, isStored: true, isRestore: true };
+ mockSessionClient.getId = jest.fn().mockResolvedValueOnce('my_id');
+ mockSessionClient.trackId = jest.fn();
+
+ await mockScopedClient.search(searchRequest, options).toPromise();
+
+ expect(mockSessionClient.trackId).not.toBeCalled();
+ });
+
+ it('does not call `trackId` if no session id provided', async () => {
+ const searchRequest = { params: {} };
+ const options = {};
+ mockSessionClient.getId = jest.fn().mockResolvedValueOnce('my_id');
+ mockSessionClient.trackId = jest.fn();
+
+ await mockScopedClient.search(searchRequest, options).toPromise();
+
+ expect(mockSessionClient.trackId).not.toBeCalled();
+ });
+ });
+ });
 });

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

@@ -19,7 +19,7 @@ import {
  SharedGlobalConfig,
  StartServicesAccessor,
 } from 'src/core/server';
-import { first, switchMap } from 'rxjs/operators';
+import { first, switchMap, tap } from 'rxjs/operators';
 import { BfetchServerSetup } from 'src/plugins/bfetch/server';
 import { ExpressionsServerSetup } from 'src/plugins/expressions/server';
 import type {
@@ -65,7 +65,6 @@ import { aggShardDelay } from '../../common/search/aggs/buckets/shard_delay_fn';
 import { ConfigSchema } from '../../config';
 import { ISearchSessionService, SearchSessionService } from './session';
 import { KbnServerError } from '../../../kibana_utils/server';
-import { tapFirst } from '../../common';
 import { registerBsearchRoute } from './routes/bsearch';
 
 type StrategyMap = Record<string, ISearchStrategy<any, any>>;
@@ -274,8 +273,8 @@ export class SearchService implements Plugin<ISearchSetup, ISearchStart> {
 
  return from(getSearchRequest()).pipe(
  switchMap((searchRequest) => strategy.search(searchRequest, options, deps)),
- tapFirst((response) => {
- if (request.id || !options.sessionId || !response.id || options.isRestore) return;
+ tap((response) => {
+ if (!options.sessionId || !response.id || options.isRestore) return;
  deps.searchSessionsClient.trackId(request, response.id, options);
  })
  );

src/plugins/data/server/search/session/types.ts

@@ -24,7 +24,7 @@ export interface IScopedSearchSessionsClient<T = unknown> {
  options: ISearchOptions
  ) => Promise<void>;
  getSearchIdMapping: (sessionId: string) => Promise<Map<string, string>>;
- save: (sessionId: string, attributes: Partial<T>) => Promise<SavedObject<T>>;
+ save: (sessionId: string, attributes: Partial<T>) => Promise<SavedObject<T> | undefined>;
  get: (sessionId: string) => Promise<SavedObject<T>>;
  find: (options: Omit<SavedObjectsFindOptions, 'type'>) => Promise<SavedObjectsFindResponse<T>>;
  update: (sessionId: string, attributes: Partial<T>) => Promise<SavedObjectsUpdateResponse<T>>;

x-pack/plugins/data_enhanced/common/index.ts

@@ -5,6 +5,7 @@
  */
 
 export {
+ SEARCH_SESSION_TYPE,
  ENHANCED_ES_SEARCH_STRATEGY,
  EQL_SEARCH_STRATEGY,
  EqlRequestParams,

x-pack/plugins/data_enhanced/common/search/session/types.ts

@@ -6,19 +6,25 @@
 
 import { SearchSessionStatus } from './';
 
+export const SEARCH_SESSION_TYPE = 'search-session';
 export interface SearchSessionSavedObjectAttributes {
+ sessionId: string;
  /**
  * User-facing session name to be displayed in session management
  */
- name: string;
+ name?: string;
  /**
  * App that created the session. e.g 'discover'
  */
- appId: string;
+ appId?: string;
  /**
  * Creation time of the session
  */
  created: string;
+ /**
+ * Last touch time of the session
+ */
+ touched: string;
  /**
  * Expiration time of the session. Expiration itself is managed by Elasticsearch.
  */
@@ -30,22 +36,28 @@ export interface SearchSessionSavedObjectAttributes {
  /**
  * urlGeneratorId
  */
- urlGeneratorId: string;
+ urlGeneratorId?: string;
  /**
  * The application state that was used to create the session.
  * Should be used, for example, to re-load an expired search session.
  */
- initialState: Record<string, unknown>;
+ initialState?: Record<string, unknown>;
  /**
  * Application state that should be used to restore the session.
  * For example, relative dates are conveted to absolute ones.
  */
- restoreState: Record<string, unknown>;
+ restoreState?: Record<string, unknown>;
  /**
  * Mapping of search request hashes to their corresponsing info (async search id, etc.)
  */
  idMapping: Record<string, SearchSessionRequestInfo>;
+
+ /**
+ * This value is true if the session was actively stored by the user. If it is false, the session may be purged by the system.
+ */
+ persisted: boolean;
 }
+
 export interface SearchSessionRequestInfo {
  /**
  * ID of the async search request

x-pack/plugins/data_enhanced/config.ts

@@ -9,15 +9,49 @@ import { schema, TypeOf } from '@kbn/config-schema';
 export const configSchema = schema.object({
  search: schema.object({
  sessions: schema.object({
+ /**
+ * Turns the feature on \ off (incl. removing indicator and management screens)
+ */
  enabled: schema.boolean({ defaultValue: false }),
+ /**
+ * pageSize controls how many search session objects we load at once while monitoring
+ * session completion
+ */
  pageSize: schema.number({ defaultValue: 10000 }),
+ /**
+ * trackingInterval controls how often we track search session objects progress
+ */
  trackingInterval: schema.duration({ defaultValue: '10s' }),
- inMemTimeout: schema.duration({ defaultValue: '1m' }),
+ /**
+ * notTouchedTimeout controls how long do we store unpersisted search session results,
+ * after the last search in the session has completed
+ */
+ notTouchedTimeout: schema.duration({ defaultValue: '5m' }),
+ /**
+ * notTouchedInProgressTimeout controls how long do allow a search session to run after
+ * a user has navigated away without persisting
+ */
+ notTouchedInProgressTimeout: schema.duration({ defaultValue: '1m' }),
+ /**
+ * maxUpdateRetries controls how many retries we perform while attempting to save a search session
+ */
  maxUpdateRetries: schema.number({ defaultValue: 3 }),
+ /**
+ * defaultExpiration controls how long search sessions are valid for, until they are expired.
+ */
  defaultExpiration: schema.duration({ defaultValue: '7d' }),
  management: schema.object({
+ /**
+ * maxSessions controls how many saved search sessions we display per page on the management screen.
+ */
  maxSessions: schema.number({ defaultValue: 10000 }),
+ /**
+ * refreshInterval controls how often we refresh the management screen.
+ */
  refreshInterval: schema.duration({ defaultValue: '10s' }),
+ /**
+ * refreshTimeout controls how often we refresh the management screen.
+ */
  refreshTimeout: schema.duration({ defaultValue: '1m' }),
  expiresSoonWarning: schema.duration({ defaultValue: '1d' }),
  }),