[data.search] Use incrementCounter for search telemetry

src/plugins/data/server/saved_objects/migrations/to_v7_12_0.ts

@@ -0,0 +1,17 @@
+/*
+ * 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 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+import type { SavedObjectMigrationFn } from 'kibana/server';
+
+/**
+ * Drop the previous document's attributes, which report `averageDuration` incorrectly.
+ * @param doc
+ */
+export const migrate712: SavedObjectMigrationFn = (doc) => {
+  return { ...doc, attributes: {} };
+};

src/plugins/data/server/saved_objects/search_telemetry.ts

@@ -7,6 +7,7 @@
  */
 
 import { SavedObjectsType } from 'kibana/server';
+import { migrate712 } from './migrations/to_v7_12_0';
 
 export const searchTelemetry: SavedObjectsType = {
   name: 'search-telemetry',
@@ -16,4 +17,7 @@ export const searchTelemetry: SavedObjectsType = {
     dynamic: false,
     properties: {},
   },
+  migrations: {
+    '7.12.0': migrate712,
+  },
 };

src/plugins/data/server/search/collectors/fetch.ts

@@ -11,14 +11,14 @@ import { first } from 'rxjs/operators';
 import { SharedGlobalConfig } from 'kibana/server';
 import { SearchResponse } from 'elasticsearch';
 import { CollectorFetchContext } from 'src/plugins/usage_collection/server';
-import { Usage } from './register';
+import { CollectedUsage, ReportedUsage } from './register';
 interface SearchTelemetry {
-  'search-telemetry': Usage;
+  'search-telemetry': CollectedUsage;
 }
 type ESResponse = SearchResponse<SearchTelemetry>;
 
 export function fetchProvider(config$: Observable<SharedGlobalConfig>) {
-  return async ({ esClient }: CollectorFetchContext): Promise<Usage> => {
+  return async ({ esClient }: CollectorFetchContext): Promise<ReportedUsage> => {
     const config = await config$.pipe(first()).toPromise();
     const { body: esResponse } = await esClient.search<ESResponse>(
       {
@@ -37,6 +37,10 @@ export function fetchProvider(config$: Observable<SharedGlobalConfig>) {
         averageDuration: null,
       };
     }
-    return esResponse.hits.hits[0]._source['search-telemetry'];
+    const { successCount, errorCount, totalDuration } = esResponse.hits.hits[0]._source[
+      'search-telemetry'
+    ];
+    const averageDuration = totalDuration / successCount;
+    return { successCount, errorCount, averageDuration };
   };
 }

src/plugins/data/server/search/collectors/register.ts

@@ -10,7 +10,13 @@ import { PluginInitializerContext } from 'kibana/server';
 import { UsageCollectionSetup } from '../../../../usage_collection/server';
 import { fetchProvider } from './fetch';
 
-export interface Usage {
+export interface CollectedUsage {
+  successCount: number;
+  errorCount: number;
+  totalDuration: number;
+}
+
+export interface ReportedUsage {
   successCount: number;
   errorCount: number;
   averageDuration: number | null;
@@ -21,7 +27,7 @@ export async function registerUsageCollector(
   context: PluginInitializerContext
 ) {
   try {
-    const collector = usageCollection.makeUsageCollector<Usage>({
+    const collector = usageCollection.makeUsageCollector<ReportedUsage>({
       type: 'search',
       isReady: () => true,
       fetch: fetchProvider(context.config.legacy.globalConfig$),

src/plugins/data/server/search/collectors/usage.ts

@@ -6,63 +6,56 @@
  * Side Public License, v 1.
  */
 
+import { once } from 'lodash';
 import type { CoreSetup, Logger } from 'kibana/server';
+import { SavedObjectsErrorHelpers } from '../../../../../core/server';
 import type { IEsSearchResponse } from '../../../common';
-import type { Usage } from './register';
 
 const SAVED_OBJECT_ID = 'search-telemetry';
+const MAX_RETRY_COUNT = 3;
 
 export interface SearchUsage {
   trackError(): Promise<void>;
   trackSuccess(duration: number): Promise<void>;
 }
 
 export function usageProvider(core: CoreSetup): SearchUsage {
-  const getTracker = (eventType: keyof Usage) => {
-    return async (duration?: number) => {
-      const repository = await core
-        .getStartServices()
-        .then(([coreStart]) => coreStart.savedObjects.createInternalRepository());
+  const getRepository = once(async () => {
+    const [coreStart] = await core.getStartServices();
+    return coreStart.savedObjects.createInternalRepository();
+  });
 
-      let attributes: Usage;
-      let doesSavedObjectExist: boolean = true;
-
-      try {
-        const response = await repository.get<Usage>(SAVED_OBJECT_ID, SAVED_OBJECT_ID);
-        attributes = response.attributes;
-      } catch (e) {
-        doesSavedObjectExist = false;
-        attributes = {
-          successCount: 0,
-          errorCount: 0,
-          averageDuration: 0,
-        };
-      }
-
-      attributes[eventType]++;
-
-      // Only track the average duration for successful requests
-      if (eventType === 'successCount') {
-        attributes.averageDuration =
-          ((duration ?? 0) + (attributes.averageDuration ?? 0)) / (attributes.successCount ?? 1);
+  const trackSuccess = async (duration: number, retryCount = 0) => {
+    const repository = await getRepository();
+    try {
+      await repository.incrementCounter(SAVED_OBJECT_ID, SAVED_OBJECT_ID, [
+        { fieldName: 'successCount' },
+        {
+          fieldName: 'totalDuration',
+          incrementBy: duration,
+        },
+      ]);
+    } catch (e) {
+      if (SavedObjectsErrorHelpers.isConflictError(e) && retryCount < MAX_RETRY_COUNT) {
+        setTimeout(() => trackSuccess(duration, retryCount + 1), 1000);
       }
+    }
+  };
 
-      try {
-        if (doesSavedObjectExist) {
-          await repository.update(SAVED_OBJECT_ID, SAVED_OBJECT_ID, attributes);
-        } else {
-          await repository.create(SAVED_OBJECT_ID, attributes, { id: SAVED_OBJECT_ID });
-        }
-      } catch (e) {
-        // Version conflict error, swallow
+  const trackError = async (retryCount = 0) => {
+    const repository = await getRepository();
+    try {
+      await repository.incrementCounter(SAVED_OBJECT_ID, SAVED_OBJECT_ID, [
+        { fieldName: 'errorCount' },
+      ]);
+    } catch (e) {
+      if (SavedObjectsErrorHelpers.isConflictError(e) && retryCount < MAX_RETRY_COUNT) {
+        setTimeout(() => trackError(retryCount + 1), 1000);
       }
-    };
+    }
   };
 
-  return {
-    trackError: () => getTracker('errorCount')(),
-    trackSuccess: getTracker('successCount'),
-  };
+  return { trackSuccess, trackError };
 }
 
 /**