[Maps] Fix regression preventing maps telemetry from populating & remove task manager logic

x-pack/legacy/plugins/maps/common/constants.js

@@ -23,6 +23,7 @@ export const EMS_TILES_VECTOR_TILE_PATH = 'ems/tiles/vector/tile';
 export const MAP_SAVED_OBJECT_TYPE = 'map';
 export const APP_ID = 'maps';
 export const APP_ICON = 'gisApp';
+export const TELEMETRY_TYPE = 'maps-telemetry';
 
 export const MAP_APP_PATH = `app/${APP_ID}`;
 export const GIS_API_PATH = `api/${APP_ID}`;

x-pack/legacy/plugins/maps/server/maps_telemetry/maps_telemetry.js

@@ -5,10 +5,16 @@
  */
 
 import _ from 'lodash';
-import { EMS_FILE, ES_GEO_FIELD_TYPE, MAP_SAVED_OBJECT_TYPE } from '../../common/constants';
+import {
+  EMS_FILE,
+  ES_GEO_FIELD_TYPE,
+  MAP_SAVED_OBJECT_TYPE,
+  TELEMETRY_TYPE,
+} from '../../common/constants';
 
-function getSavedObjectsClient(server, callCluster) {
+function getSavedObjectsClient(server) {
   const { SavedObjectsClient, getSavedObjectsRepository } = server.savedObjects;
+  const callCluster = server.plugins.elasticsearch.getCluster('admin').callWithInternalUser;
   const internalRepository = getSavedObjectsRepository(callCluster);
   return new SavedObjectsClient(internalRepository);
 }
@@ -79,7 +85,7 @@ export function buildMapsTelemetry({ mapSavedObjects, indexPatternSavedObjects,
     // Total count of maps
     mapsTotalCount: mapsCount,
     // Time of capture
-    timeCaptured: new Date(),
+    timeCaptured: new Date().toISOString(),
     attributesPerMap: {
       // Count of data sources per map
       dataSourcesCount: {
@@ -115,16 +121,16 @@ async function getIndexPatternSavedObjects(savedObjectsClient) {
   return _.get(indexPatternSavedObjects, 'saved_objects', []);
 }
 
-export async function getMapsTelemetry(server, callCluster) {
-  const savedObjectsClient = getSavedObjectsClient(server, callCluster);
+export async function getMapsTelemetry(server) {
+  const savedObjectsClient = getSavedObjectsClient(server);
   const mapSavedObjects = await getMapSavedObjects(savedObjectsClient);
   const indexPatternSavedObjects = await getIndexPatternSavedObjects(savedObjectsClient);
   const settings = {
     showMapVisualizationTypes: server.config().get('xpack.maps.showMapVisualizationTypes'),
   };
   const mapsTelemetry = buildMapsTelemetry({ mapSavedObjects, indexPatternSavedObjects, settings });
-  return await savedObjectsClient.create('maps-telemetry', mapsTelemetry, {
-    id: 'maps-telemetry',
+  return await savedObjectsClient.create(TELEMETRY_TYPE, mapsTelemetry, {
+    id: TELEMETRY_TYPE,
     overwrite: true,
   });
 }

x-pack/legacy/plugins/maps/server/maps_telemetry/maps_usage_collector.js

@@ -4,85 +4,19 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-import _ from 'lodash';
-import { TASK_ID, scheduleTask, registerMapsTelemetryTask } from './telemetry_task';
+import { getMapsTelemetry } from './maps_telemetry';
+import { TELEMETRY_TYPE } from '../../common/constants';
 
 export function initTelemetryCollection(usageCollection, server) {
-  registerMapsTelemetryTask(server);
-  scheduleTask(server);
-  registerMapsUsageCollector(usageCollection, server);
-}
-
-async function isTaskManagerReady(server) {
-  const result = await fetch(server);
-  return result !== null;
-}
-
-async function fetch(server) {
-  let docs;
-  const taskManager = server.plugins.task_manager;
-
-  if (!taskManager) {
-    return null;
-  }
-
-  try {
-    ({ docs } = await taskManager.fetch({
-      query: {
-        bool: {
-          filter: {
-            term: {
-              _id: `task:${TASK_ID}`,
-            },
-          },
-        },
-      },
-    }));
-  } catch (err) {
-    const errMessage = err && err.message ? err.message : err.toString();
-    /*
-     * The usage service WILL to try to fetch from this collector before the task manager has been initialized, because the task manager
-     * has to wait for all plugins to initialize first.
-     * It's fine to ignore it as next time around it will be initialized (or it will throw a different type of error)
-     */
-    if (errMessage.indexOf('NotInitialized') >= 0) {
-      return null;
-    } else {
-      throw err;
-    }
+  if (!usageCollection) {
+    return;
   }
 
-  return docs;
-}
-
-export function buildCollectorObj(server) {
-  let isCollectorReady = false;
-  async function determineIfTaskManagerIsReady() {
-    let isReady = false;
-    try {
-      isReady = await isTaskManagerReady(server);
-    } catch (err) {} // eslint-disable-line
-
-    if (isReady) {
-      isCollectorReady = true;
-    } else {
-      setTimeout(determineIfTaskManagerIsReady, 500);
-    }
-  }
-  determineIfTaskManagerIsReady();
-
-  return {
-    type: 'maps',
-    isReady: () => isCollectorReady,
-    fetch: async () => {
-      const docs = await fetch(server);
-      return _.get(docs, '[0].state.stats');
-    },
-  };
-}
+  const mapsUsageCollector = usageCollection.makeUsageCollector({
+    type: TELEMETRY_TYPE,
+    isReady: () => true,
+    fetch: async () => await getMapsTelemetry(server),
+  });
 
-export function registerMapsUsageCollector(usageCollection, server) {
-  const collectorObj = buildCollectorObj(server);
-  const mapsUsageCollector = usageCollection.makeUsageCollector(collectorObj);
   usageCollection.registerCollector(mapsUsageCollector);
 }

x-pack/legacy/plugins/maps/server/maps_telemetry/maps_usage_collector.test.js

@@ -4,60 +4,32 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-import sinon from 'sinon';
-import { getMockCallWithInternal, getMockKbnServer, getMockTaskFetch } from '../test_utils';
-import { buildCollectorObj } from './maps_usage_collector';
+import { initTelemetryCollection } from './maps_usage_collector';
 
 describe('buildCollectorObj#fetch', () => {
-  let mockKbnServer;
+  let makeUsageCollectorStub;
+  let registerStub;
+  let usageCollection;
 
   beforeEach(() => {
-    mockKbnServer = getMockKbnServer();
+    makeUsageCollectorStub = jest.fn();
+    registerStub = jest.fn();
+    usageCollection = {
+      makeUsageCollector: makeUsageCollectorStub,
+      registerCollector: registerStub,
+    };
   });
 
-  test('can return empty stats', async () => {
-    const { type, fetch } = buildCollectorObj(mockKbnServer);
-    expect(type).toBe('maps');
-    const fetchResult = await fetch();
-    expect(fetchResult).toEqual({});
-  });
-
-  test('provides known stats', async () => {
-    const mockTaskFetch = getMockTaskFetch([
-      {
-        state: {
-          runs: 2,
-          stats: { wombat_sightings: { total: 712, max: 84, min: 7, avg: 63 } },
-        },
-      },
-    ]);
-    mockKbnServer = getMockKbnServer(getMockCallWithInternal(), mockTaskFetch);
-
-    const { type, fetch } = buildCollectorObj(mockKbnServer);
-    expect(type).toBe('maps');
-    const fetchResult = await fetch();
-    expect(fetchResult).toEqual({ wombat_sightings: { total: 712, max: 84, min: 7, avg: 63 } });
-  });
-
-  describe('Error handling', () => {
-    test('Silently handles Task Manager NotInitialized', async () => {
-      const mockTaskFetch = sinon.stub();
-      mockTaskFetch.rejects(
-        new Error('NotInitialized taskManager is still waiting for plugins to load')
-      );
-      mockKbnServer = getMockKbnServer(getMockCallWithInternal(), mockTaskFetch);
-
-      const { fetch } = buildCollectorObj(mockKbnServer);
-      await expect(fetch()).resolves.toBe(undefined);
-    });
-    // In real life, the CollectorSet calls fetch and handles errors
-    test('defers the errors', async () => {
-      const mockTaskFetch = sinon.stub();
-      mockTaskFetch.rejects(new Error('Sad violin'));
-      mockKbnServer = getMockKbnServer(getMockCallWithInternal(), mockTaskFetch);
+  test('makes and registers maps usage collector', async () => {
+    const serverPlaceholder = {};
+    initTelemetryCollection(usageCollection, serverPlaceholder);
 
-      const { fetch } = buildCollectorObj(mockKbnServer);
-      await expect(fetch()).rejects.toMatchObject(new Error('Sad violin'));
+    expect(registerStub).toHaveBeenCalledTimes(1);
+    expect(makeUsageCollectorStub).toHaveBeenCalledTimes(1);
+    expect(makeUsageCollectorStub).toHaveBeenCalledWith({
+      type: expect.any(String),
+      isReady: expect.any(Function),
+      fetch: expect.any(Function),
     });
   });
 });