[Telemetry] Add telemetry.sendUsageTo config

src/dev/build/tasks/os_packages/docker_generator/resources/base/bin/kibana-docker

@@ -191,6 +191,7 @@ kibana_vars=(
     telemetry.enabled
     telemetry.optIn
     telemetry.optInStatusUrl
+    telemetry.sendUsageTo
     telemetry.sendUsageFrom
     tilemap.options.attribution
     tilemap.options.maxZoom

src/plugins/telemetry/common/constants.ts

@@ -49,3 +49,17 @@ export const PRIVACY_STATEMENT_URL = `https://www.elastic.co/legal/privacy-state
  * The endpoint version when hitting the remote telemetry service
  */
 export const ENDPOINT_VERSION = 'v2';
+
+/**
+ * The telemetry endpoints for the remote telemetry service.
+ */
+export const TELEMETRY_ENDPOINT = {
+  MAIN_CHANNEL: {
+    PROD: `https://telemetry.elastic.co/xpack/${ENDPOINT_VERSION}/send`,
+    STAGING: `https://telemetry-staging.elastic.co/xpack/${ENDPOINT_VERSION}/send`,
+  },
+  OPT_IN_STATUS_CHANNEL: {
+    PROD: `https://telemetry.elastic.co/opt_in_status/${ENDPOINT_VERSION}/send`,
+    STAGING: `https://telemetry-staging.elastic.co/opt_in_status/${ENDPOINT_VERSION}/send`,
+  },
+};

src/plugins/telemetry/common/telemetry_config/get_telemetry_channel_endpoint.test.ts

@@ -0,0 +1,48 @@
+/*
+ * 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 { getTelemetryChannelEndpoint } from './get_telemetry_channel_endpoint';
+import { TELEMETRY_ENDPOINT } from '../constants';
+
+describe('getTelemetryChannelEndpoint', () => {
+  it('throws on unknown env', () => {
+    expect(() =>
+      // @ts-expect-error
+      getTelemetryChannelEndpoint({ env: 'ANY', channelName: 'main' })
+    ).toThrowErrorMatchingInlineSnapshot(`"Unknown telemetry endpoint env ANY."`);
+  });
+
+  it('throws on unknown channelName', () => {
+    expect(() =>
+      // @ts-expect-error
+      getTelemetryChannelEndpoint({ env: 'prod', channelName: 'ANY' })
+    ).toThrowErrorMatchingInlineSnapshot(`"Unknown telemetry channel ANY."`);
+  });
+
+  describe('main channel', () => {
+    it('returns correct prod endpoint', () => {
+      const endpoint = getTelemetryChannelEndpoint({ env: 'prod', channelName: 'main' });
+      expect(endpoint).toBe(TELEMETRY_ENDPOINT.MAIN_CHANNEL.PROD);
+    });
+    it('returns correct staging endpoint', () => {
+      const endpoint = getTelemetryChannelEndpoint({ env: 'staging', channelName: 'main' });
+      expect(endpoint).toBe(TELEMETRY_ENDPOINT.MAIN_CHANNEL.STAGING);
+    });
+  });
+
+  describe('optInStatus channel', () => {
+    it('returns correct prod endpoint', () => {
+      const endpoint = getTelemetryChannelEndpoint({ env: 'prod', channelName: 'optInStatus' });
+      expect(endpoint).toBe(TELEMETRY_ENDPOINT.OPT_IN_STATUS_CHANNEL.PROD);
+    });
+    it('returns correct staging endpoint', () => {
+      const endpoint = getTelemetryChannelEndpoint({ env: 'staging', channelName: 'optInStatus' });
+      expect(endpoint).toBe(TELEMETRY_ENDPOINT.OPT_IN_STATUS_CHANNEL.STAGING);
+    });
+  });
+});

src/plugins/telemetry/common/telemetry_config/get_telemetry_channel_endpoint.ts

@@ -0,0 +1,34 @@
+/*
+ * 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 { TELEMETRY_ENDPOINT } from '../constants';
+
+export interface GetTelemetryChannelEndpointConfig {
+  channelName: 'main' | 'optInStatus';
+  env: 'staging' | 'prod';
+}
+
+export function getTelemetryChannelEndpoint({
+  channelName,
+  env,
+}: GetTelemetryChannelEndpointConfig): string {
+  if (env !== 'staging' && env !== 'prod') {
+    throw new Error(`Unknown telemetry endpoint env ${env}.`);
+  }
+
+  const endpointEnv = env === 'staging' ? 'STAGING' : 'PROD';
+
+  switch (channelName) {
+    case 'main':
+      return TELEMETRY_ENDPOINT.MAIN_CHANNEL[endpointEnv];
+    case 'optInStatus':
+      return TELEMETRY_ENDPOINT.OPT_IN_STATUS_CHANNEL[endpointEnv];
+    default:
+      throw new Error(`Unknown telemetry channel ${channelName}.`);
+  }
+}

src/plugins/telemetry/common/telemetry_config/index.ts

@@ -11,3 +11,5 @@ export { getTelemetrySendUsageFrom } from './get_telemetry_send_usage_from';
 export { getTelemetryAllowChangingOptInStatus } from './get_telemetry_allow_changing_opt_in_status';
 export { getTelemetryFailureDetails } from './get_telemetry_failure_details';
 export type { TelemetryFailureDetails } from './get_telemetry_failure_details';
+export { getTelemetryChannelEndpoint } from './get_telemetry_channel_endpoint';
+export type { GetTelemetryChannelEndpointConfig } from './get_telemetry_channel_endpoint';

src/plugins/telemetry/public/mocks.ts

@@ -34,8 +34,7 @@ export function mockTelemetryService({
 }: TelemetryServiceMockOptions = {}) {
   const config = {
     enabled: true,
-    url: 'http://localhost',
-    optInStatusUrl: 'http://localhost',
+    sendUsageTo: 'staging' as const,
     sendUsageFrom: 'browser' as const,
     optIn: true,
     banner: true,

src/plugins/telemetry/public/plugin.ts

@@ -90,16 +90,14 @@ interface TelemetryPluginSetupDependencies {
 export interface TelemetryPluginConfig {
   /** Is the plugin enabled? **/
   enabled: boolean;
-  /** Remote telemetry service's URL **/
-  url: string;
   /** The banner is expected to be shown when needed **/
   banner: boolean;
   /** Does the cluster allow changing the opt-in/out status via the UI? **/
   allowChangingOptInStatus: boolean;
   /** Is the cluster opted-in? **/
   optIn: boolean | null;
-  /** Opt-in/out notification URL **/
-  optInStatusUrl: string;
+  /** Specify if telemetry should send usage to the prod or staging remote telemetry service **/
+  sendUsageTo: 'prod' | 'staging';
   /** Should the telemetry payloads be sent from the server or the browser? **/
   sendUsageFrom: 'browser' | 'server';
   /** Should notify the user about the opt-in status? **/

src/plugins/telemetry/public/services/telemetry_service.test.ts

@@ -10,7 +10,7 @@
 /* eslint-disable dot-notation */
 
 import { mockTelemetryService } from '../mocks';
-
+import { TELEMETRY_ENDPOINT } from '../../common/constants';
 describe('TelemetryService', () => {
   describe('fetchTelemetry', () => {
     it('calls expected URL with 20 minutes - now', async () => {
@@ -137,13 +137,42 @@ describe('TelemetryService', () => {
   });
 
   describe('getTelemetryUrl', () => {
-    it('should return the config.url parameter', async () => {
-      const url = 'http://test.com';
+    it('should return staging endpoint when sendUsageTo is set to staging', async () => {
+      const telemetryService = mockTelemetryService({
+        config: { sendUsageTo: 'staging' },
+      });
+
+      expect(telemetryService.getTelemetryUrl()).toBe(TELEMETRY_ENDPOINT.MAIN_CHANNEL.STAGING);
+    });
+
+    it('should return prod endpoint when sendUsageTo is set to prod', async () => {
+      const telemetryService = mockTelemetryService({
+        config: { sendUsageTo: 'prod' },
+      });
+
+      expect(telemetryService.getTelemetryUrl()).toBe(TELEMETRY_ENDPOINT.MAIN_CHANNEL.PROD);
+    });
+  });
+
+  describe('getOptInStatusUrl', () => {
+    it('should return staging endpoint when sendUsageTo is set to staging', async () => {
+      const telemetryService = mockTelemetryService({
+        config: { sendUsageTo: 'staging' },
+      });
+
+      expect(telemetryService.getOptInStatusUrl()).toBe(
+        TELEMETRY_ENDPOINT.OPT_IN_STATUS_CHANNEL.STAGING
+      );
+    });
+
+    it('should return prod endpoint when sendUsageTo is set to prod', async () => {
       const telemetryService = mockTelemetryService({
-        config: { url },
+        config: { sendUsageTo: 'prod' },
       });
 
-      expect(telemetryService.getTelemetryUrl()).toBe(url);
+      expect(telemetryService.getOptInStatusUrl()).toBe(
+        TELEMETRY_ENDPOINT.OPT_IN_STATUS_CHANNEL.PROD
+      );
     });
   });
 

src/plugins/telemetry/public/services/telemetry_service.ts

@@ -9,6 +9,7 @@
 import { i18n } from '@kbn/i18n';
 import { CoreStart } from 'kibana/public';
 import { TelemetryPluginConfig } from '../plugin';
+import { getTelemetryChannelEndpoint } from '../../common/telemetry_config';
 
 interface TelemetryServiceConstructor {
   config: TelemetryPluginConfig;
@@ -93,14 +94,14 @@ export class TelemetryService {
 
   /** Retrieve the opt-in/out notification URL **/
   public getOptInStatusUrl = () => {
-    const telemetryOptInStatusUrl = this.config.optInStatusUrl;
-    return telemetryOptInStatusUrl;
+    const { sendUsageTo } = this.config;
+    return getTelemetryChannelEndpoint({ channelName: 'optInStatus', env: sendUsageTo });
   };
 
   /** Retrieve the URL to report telemetry **/
   public getTelemetryUrl = () => {
-    const telemetryUrl = this.config.url;
-    return telemetryUrl;
+    const { sendUsageTo } = this.config;
+    return getTelemetryChannelEndpoint({ channelName: 'main', env: sendUsageTo });
   };
 
   /**

src/plugins/telemetry/server/config.ts → src/plugins/telemetry/server/config/config.ts

@@ -6,11 +6,18 @@
  * Side Public License, v 1.
  */
 
-import { schema, TypeOf } from '@kbn/config-schema';
+import { schema, TypeOf, Type } from '@kbn/config-schema';
 import { getConfigPath } from '@kbn/utils';
-import { ENDPOINT_VERSION } from '../common/constants';
+import { PluginConfigDescriptor } from 'kibana/server';
+import { TELEMETRY_ENDPOINT } from '../../common/constants';
+import { deprecateEndpointConfigs } from './deprecations';
 
-export const configSchema = schema.object({
+const clusterEnvSchema: [Type<'prod'>, Type<'staging'>] = [
+  schema.literal('prod'),
+  schema.literal('staging'),
+];
+
+const configSchema = schema.object({
   enabled: schema.boolean({ defaultValue: true }),
   allowChangingOptInStatus: schema.boolean({ defaultValue: true }),
   optIn: schema.conditional(
@@ -23,24 +30,38 @@ export const configSchema = schema.object({
   // `config` is used internally and not intended to be set
   config: schema.string({ defaultValue: getConfigPath() }),
   banner: schema.boolean({ defaultValue: true }),
+  sendUsageTo: schema.conditional(
+    schema.contextRef('dist'),
+    schema.literal(false), // Point to staging if it's not a distributable release
+    schema.oneOf(clusterEnvSchema, { defaultValue: 'staging' }),
+    schema.oneOf(clusterEnvSchema, { defaultValue: 'prod' })
+  ),
+  /**
+   * REMOVE IN 8.0 - INTERNAL CONFIG DEPRECATED IN 7.15
+   * REPLACED WITH `telemetry.sendUsageTo: staging | prod`
+   */
   url: schema.conditional(
     schema.contextRef('dist'),
     schema.literal(false), // Point to staging if it's not a distributable release
     schema.string({
-      defaultValue: `https://telemetry-staging.elastic.co/xpack/${ENDPOINT_VERSION}/send`,
+      defaultValue: TELEMETRY_ENDPOINT.MAIN_CHANNEL.STAGING,
     }),
     schema.string({
-      defaultValue: `https://telemetry.elastic.co/xpack/${ENDPOINT_VERSION}/send`,
+      defaultValue: TELEMETRY_ENDPOINT.MAIN_CHANNEL.PROD,
     })
   ),
+  /**
+   * REMOVE IN 8.0 - INTERNAL CONFIG DEPRECATED IN 7.15
+   * REPLACED WITH `telemetry.sendUsageTo: staging | prod`
+   */
   optInStatusUrl: schema.conditional(
     schema.contextRef('dist'),
     schema.literal(false), // Point to staging if it's not a distributable release
     schema.string({
-      defaultValue: `https://telemetry-staging.elastic.co/opt_in_status/${ENDPOINT_VERSION}/send`,
+      defaultValue: TELEMETRY_ENDPOINT.OPT_IN_STATUS_CHANNEL.STAGING,
     }),
     schema.string({
-      defaultValue: `https://telemetry.elastic.co/opt_in_status/${ENDPOINT_VERSION}/send`,
+      defaultValue: TELEMETRY_ENDPOINT.OPT_IN_STATUS_CHANNEL.PROD,
     })
   ),
   sendUsageFrom: schema.oneOf([schema.literal('server'), schema.literal('browser')], {
@@ -49,3 +70,16 @@ export const configSchema = schema.object({
 });
 
 export type TelemetryConfigType = TypeOf<typeof configSchema>;
+
+export const config: PluginConfigDescriptor<TelemetryConfigType> = {
+  schema: configSchema,
+  exposeToBrowser: {
+    enabled: true,
+    banner: true,
+    allowChangingOptInStatus: true,
+    optIn: true,
+    sendUsageFrom: true,
+    sendUsageTo: true,
+  },
+  deprecations: () => [deprecateEndpointConfigs],
+};