Migrate kql telemetry and scripts api

src/legacy/core_plugins/kibana/index.js

@@ -26,14 +26,11 @@ import { importApi } from './server/routes/api/import';
 import { exportApi } from './server/routes/api/export';
 import { homeApi } from './server/routes/api/home';
 import { managementApi } from './server/routes/api/management';
-import { scriptsApi } from './server/routes/api/scripts';
-import { registerKqlTelemetryApi } from './server/routes/api/kql_telemetry';
 import { registerFieldFormats } from './server/field_formats/register';
 import { registerTutorials } from './server/tutorials/register';
 import * as systemApi from './server/lib/system_api';
 import mappings from './mappings.json';
 import { getUiSettingDefaults } from './ui_setting_defaults';
-import { makeKQLUsageCollector } from './server/lib/kql_usage_collector';
 import { registerCspCollector } from './server/lib/csp_usage_collector';
 import { injectVars } from './inject_vars';
 import { i18n } from '@kbn/i18n';
@@ -325,15 +322,12 @@ export default function(kibana) {
     init: async function(server) {
       const { usageCollection } = server.newPlatform.setup.plugins;
       // routes
-      scriptsApi(server);
       importApi(server);
       exportApi(server);
       homeApi(server);
       managementApi(server);
-      registerKqlTelemetryApi(server);
       registerFieldFormats(server);
       registerTutorials(server);
-      makeKQLUsageCollector(usageCollection, server);
       registerCspCollector(usageCollection, server);
       server.expose('systemApi', systemApi);
       server.injectUiAppVars('kibana', () => injectVars(server));

src/legacy/core_plugins/kibana/ui_setting_defaults.js

@@ -20,6 +20,7 @@
 import moment from 'moment-timezone';
 import numeralLanguages from '@elastic/numeral/languages';
 import { i18n } from '@kbn/i18n';
+import { DEFAULT_QUERY_LANGUAGE } from '../../../plugins/data/common';
 
 export function getUiSettingDefaults() {
   const weekdays = moment.weekdays().slice();
@@ -121,7 +122,7 @@ export function getUiSettingDefaults() {
     },
     'search:queryLanguage': {
       name: queryLanguageSettingName,
-      value: 'kuery',
+      value: DEFAULT_QUERY_LANGUAGE,
       description: i18n.translate('kbn.advancedSettings.searchQueryLanguageText', {
         defaultMessage:
           'Query language used by the query bar. KQL is a new language built specifically for Kibana.',

src/legacy/core_plugins/kibana/server/routes/api/scripts/index.js → src/plugins/data/common/constants.ts

@@ -17,8 +17,4 @@
  * under the License.
  */
 
-import { registerLanguages } from './register_languages';
-
-export function scriptsApi(server) {
-  registerLanguages(server);
-}
+export const DEFAULT_QUERY_LANGUAGE = 'kuery';

src/plugins/data/common/index.ts

@@ -24,3 +24,4 @@ export * from './index_patterns';
 export * from './es_query';
 export * from './utils';
 export * from './types';
+export * from './constants';

src/plugins/data/kibana.json

@@ -3,5 +3,6 @@
   "version": "kibana",
   "server": true,
   "ui": true,
-  "requiredPlugins": ["uiActions"]
+  "requiredPlugins": ["uiActions"],
+  "optionalPlugins": ["usageCollection"]
 }

src/legacy/core_plugins/kibana/server/routes/api/scripts/register_languages.js → src/plugins/data/server/kql_telemetry/index.ts

@@ -17,12 +17,4 @@
  * under the License.
  */
 
-export function registerLanguages(server) {
-  server.route({
-    path: '/api/kibana/scripts/languages',
-    method: 'GET',
-    handler: function() {
-      return ['painless', 'expression'];
-    },
-  });
-}
+export { KqlTelemetryService } from './kql_telemetry_service';

src/plugins/data/server/kql_telemetry/kql_telemetry_service.ts

@@ -0,0 +1,48 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { first } from 'rxjs/operators';
+import { CoreSetup, Plugin, PluginInitializerContext } from 'kibana/server';
+import { registerKqlTelemetryRoute } from './route';
+import { UsageCollectionSetup } from '../../../usage_collection/server';
+import { makeKQLUsageCollector } from './usage_collector';
+
+export class KqlTelemetryService implements Plugin<void> {
+  constructor(private initializerContext: PluginInitializerContext) {}
+
+  public async setup(
+    { http, savedObjects }: CoreSetup,
+    { usageCollection }: { usageCollection?: UsageCollectionSetup }
+  ) {
+    registerKqlTelemetryRoute(
+      http.createRouter(),
+      savedObjects,
+      this.initializerContext.logger.get('data', 'kql-telemetry')
+    );
+
+    if (usageCollection) {
+      const config = await this.initializerContext.config.legacy.globalConfig$
+        .pipe(first())
+        .toPromise();
+      makeKQLUsageCollector(usageCollection, config.kibana.index);
+    }
+  }
+
+  public start() {}
+}

src/legacy/core_plugins/kibana/server/routes/api/kql_telemetry/index.js → src/plugins/data/server/kql_telemetry/route.ts

@@ -17,44 +17,48 @@
  * under the License.
  */
 
-import Joi from 'joi';
-import Boom from 'boom';
+import { CoreSetup, IRouter, Logger } from 'kibana/server';
+import { schema } from '@kbn/config-schema';
 
-export function registerKqlTelemetryApi(server) {
-  server.route({
-    path: '/api/kibana/kql_opt_in_telemetry',
-    method: 'POST',
-    config: {
+export function registerKqlTelemetryRoute(
+  router: IRouter,
+  savedObjects: CoreSetup['savedObjects'],
+  logger: Logger
+) {
+  router.post(
+    {
+      path: '/api/kibana/kql_opt_in_telemetry',
       validate: {
-        payload: Joi.object({
-          opt_in: Joi.bool().required(),
+        body: schema.object({
+          opt_in: schema.boolean(),
         }),
       },
-      tags: ['api'],
     },
-    handler: async function(request) {
-      const {
-        savedObjects: { getSavedObjectsRepository },
-      } = server;
-      const { callWithInternalUser } = server.plugins.elasticsearch.getCluster('admin');
-      const internalRepository = getSavedObjectsRepository(callWithInternalUser);
+    async (context, request, response) => {
+      const internalRepository = savedObjects.createScopedRepository(request);
 
       const {
-        payload: { opt_in: optIn },
+        body: { opt_in: optIn },
       } = request;
 
       const counterName = optIn ? 'optInCount' : 'optOutCount';
 
       try {
         await internalRepository.incrementCounter('kql-telemetry', 'kql-telemetry', counterName);
       } catch (error) {
-        return new Boom('Something went wrong', {
+        logger.warn(`Unable to increment counter: ${error}`);
+        return response.customError({
           statusCode: error.status,
-          data: { success: false },
+          body: {
+            message: 'Something went wrong',
+            attributes: {
+              success: false,
+            },
+          },
         });
       }
 
-      return { success: true };
-    },
-  });
+      return response.ok({ body: { success: true } });
+    }
+  );
 }

src/legacy/core_plugins/kibana/server/lib/kql_usage_collector/fetch.test.js → src/plugins/data/server/kql_telemetry/usage_collector/fetch.test.ts

@@ -17,18 +17,22 @@
  * under the License.
  */
 
-jest.mock('../../../ui_setting_defaults', () => ({
-  getUiSettingDefaults: () => ({ 'search:queryLanguage': { value: 'lucene' } }),
-}));
-
 import { fetchProvider } from './fetch';
+import { APICaller } from 'kibana/server';
+
+jest.mock('../../../common', () => ({
+  DEFAULT_QUERY_LANGUAGE: 'lucene',
+}));
 
-let fetch;
-let callCluster;
+let fetch: ReturnType<typeof fetchProvider>;
+let callCluster: APICaller;
 
-function setupMockCallCluster(optCount, language) {
-  callCluster = jest.fn((method, params) => {
-    if ('id' in params && params.id === 'kql-telemetry:kql-telemetry') {
+function setupMockCallCluster(
+  optCount: { optInCount?: number; optOutCount?: number } | null,
+  language: string | undefined | null
+) {
+  callCluster = (jest.fn((method, params) => {
+    if (params && 'id' in params && params.id === 'kql-telemetry:kql-telemetry') {
       if (optCount === null) {
         return Promise.resolve({
           _index: '.kibana_1',
@@ -46,9 +50,9 @@ function setupMockCallCluster(optCount, language) {
           },
         });
       }
-    } else if ('body' in params && params.body.query.term.type === 'config') {
+    } else if (params && 'body' in params && params.body.query.term.type === 'config') {
       if (language === 'missingConfigDoc') {
-        Promise.resolve({
+        return Promise.resolve({
           hits: {
             hits: [],
           },
@@ -69,7 +73,9 @@ function setupMockCallCluster(optCount, language) {
         });
       }
     }
-  });
+
+    throw new Error('invalid call');
+  }) as unknown) as APICaller;
 }
 
 describe('makeKQLUsageCollector', () => {

src/legacy/core_plugins/kibana/server/lib/kql_usage_collector/fetch.js → src/plugins/data/server/kql_telemetry/usage_collector/fetch.ts

@@ -17,14 +17,14 @@
  * under the License.
  */
 
-import { getUiSettingDefaults } from '../../../ui_setting_defaults';
 import { get } from 'lodash';
+import { APICaller } from 'kibana/server';
+import { DEFAULT_QUERY_LANGUAGE } from '../../../common';
 
-const uiSettingDefaults = getUiSettingDefaults();
-const defaultSearchQueryLanguageSetting = uiSettingDefaults['search:queryLanguage'].value;
+const defaultSearchQueryLanguageSetting = DEFAULT_QUERY_LANGUAGE;
 
-export function fetchProvider(index) {
-  return async callCluster => {
+export function fetchProvider(index: string) {
+  return async (callCluster: APICaller) => {
     const [response, config] = await Promise.all([
       callCluster('get', {
         index,

src/legacy/core_plugins/kibana/server/lib/kql_usage_collector/make_kql_usage_collector.test.js → src/plugins/data/server/kql_telemetry/usage_collector/make_kql_usage_collector.test.ts

@@ -18,33 +18,26 @@
  */
 
 import { makeKQLUsageCollector } from './make_kql_usage_collector';
+import { UsageCollectionSetup } from '../../../../usage_collection/server';
 
 describe('makeKQLUsageCollector', () => {
-  let server;
-  let makeUsageCollectorStub;
-  let registerStub;
-  let usageCollection;
+  let usageCollectionMock: jest.Mocked<UsageCollectionSetup>;
 
   beforeEach(() => {
-    makeUsageCollectorStub = jest.fn();
-    registerStub = jest.fn();
-    usageCollection = {
-      makeUsageCollector: makeUsageCollectorStub,
-      registerCollector: registerStub,
-    };
-    server = {
-      config: () => ({ get: () => '.kibana' }),
-    };
+    usageCollectionMock = ({
+      makeUsageCollector: jest.fn(),
+      registerCollector: jest.fn(),
+    } as unknown) as jest.Mocked<UsageCollectionSetup>;
   });
 
   it('should call registerCollector', () => {
-    makeKQLUsageCollector(usageCollection, server);
-    expect(registerStub).toHaveBeenCalledTimes(1);
+    makeKQLUsageCollector(usageCollectionMock, '.kibana');
+    expect(usageCollectionMock.registerCollector).toHaveBeenCalledTimes(1);
   });
 
   it('should call makeUsageCollector with type = kql', () => {
-    makeKQLUsageCollector(usageCollection, server);
-    expect(makeUsageCollectorStub).toHaveBeenCalledTimes(1);
-    expect(makeUsageCollectorStub.mock.calls[0][0].type).toBe('kql');
+    makeKQLUsageCollector(usageCollectionMock, '.kibana');
+    expect(usageCollectionMock.makeUsageCollector).toHaveBeenCalledTimes(1);
+    expect(usageCollectionMock.makeUsageCollector.mock.calls[0][0].type).toBe('kql');
   });
 });

src/legacy/core_plugins/kibana/server/lib/kql_usage_collector/make_kql_usage_collector.js → src/plugins/data/server/kql_telemetry/usage_collector/make_kql_usage_collector.ts

@@ -18,10 +18,13 @@
  */
 
 import { fetchProvider } from './fetch';
+import { UsageCollectionSetup } from '../../../../usage_collection/server';
 
-export function makeKQLUsageCollector(usageCollection, server) {
-  const index = server.config().get('kibana.index');
-  const fetch = fetchProvider(index);
+export async function makeKQLUsageCollector(
+  usageCollection: UsageCollectionSetup,
+  kibanaIndex: string
+) {
+  const fetch = fetchProvider(kibanaIndex);
   const kqlUsageCollector = usageCollection.makeUsageCollector({
     type: 'kql',
     fetch,

src/plugins/data/server/plugin.ts

@@ -21,29 +21,42 @@ import { PluginInitializerContext, CoreSetup, CoreStart, Plugin } from '../../..
 import { IndexPatternsService } from './index_patterns';
 import { ISearchSetup } from './search';
 import { SearchService } from './search/search_service';
+import { ScriptsService } from './scripts';
+import { KqlTelemetryService } from './kql_telemetry';
+import { UsageCollectionSetup } from '../../usage_collection/server';
 import { AutocompleteService } from './autocomplete';
 
 export interface DataPluginSetup {
   search: ISearchSetup;
 }
 
+export interface DataPluginSetupDependencies {
+  usageCollection?: UsageCollectionSetup;
+}
 export class DataServerPlugin implements Plugin<DataPluginSetup> {
   private readonly searchService: SearchService;
+  private readonly scriptsService: ScriptsService;
+  private readonly kqlTelemetryService: KqlTelemetryService;
   private readonly autocompleteService = new AutocompleteService();
   private readonly indexPatterns = new IndexPatternsService();
 
   constructor(initializerContext: PluginInitializerContext) {
     this.searchService = new SearchService(initializerContext);
+    this.scriptsService = new ScriptsService();
+    this.kqlTelemetryService = new KqlTelemetryService(initializerContext);
   }
 
-  public setup(core: CoreSetup) {
+  public async setup(core: CoreSetup, { usageCollection }: DataPluginSetupDependencies) {
     this.indexPatterns.setup(core);
+    this.scriptsService.setup(core);
     this.autocompleteService.setup(core);
+    this.kqlTelemetryService.setup(core, { usageCollection });
 
     return {
       search: this.searchService.setup(core),
     };
   }
+
   public start(core: CoreStart) {}
   public stop() {}
 }