Fixed usage of isReady for usage collection of alerts and actions

x-pack/plugins/actions/server/plugin.ts

@@ -4,16 +4,16 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 import type { PublicMethodsOf } from '@kbn/utility-types';
-import { first, map } from 'rxjs/operators';
+import { first } from 'rxjs/operators';
 import { UsageCollectionSetup } from 'src/plugins/usage_collection/server';
+import { Observable } from 'rxjs';
 import {
   PluginInitializerContext,
   Plugin,
   CoreSetup,
   CoreStart,
   KibanaRequest,
   Logger,
-  SharedGlobalConfig,
   RequestHandler,
   IContextProvider,
   ElasticsearchServiceStart,
@@ -128,7 +128,6 @@ const includedHiddenTypes = [
 ];
 
 export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, PluginStartContract> {
-  private readonly kibanaIndex: Promise<string>;
   private readonly config: Promise<ActionsConfig>;
 
   private readonly logger: Logger;
@@ -145,20 +144,14 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
   private isESOUsingEphemeralEncryptionKey?: boolean;
   private readonly telemetryLogger: Logger;
   private readonly preconfiguredActions: PreConfiguredAction[];
+  private readonly kibanaIndexConfig: Observable<{ kibana: { index: string } }>;
 
   constructor(initContext: PluginInitializerContext) {
     this.config = initContext.config.create<ActionsConfig>().pipe(first()).toPromise();
-
-    this.kibanaIndex = initContext.config.legacy.globalConfig$
-      .pipe(
-        first(),
-        map((config: SharedGlobalConfig) => config.kibana.index)
-      )
-      .toPromise();
-
     this.logger = initContext.logger.get('actions');
     this.telemetryLogger = initContext.logger.get('usage');
     this.preconfiguredActions = [];
+    this.kibanaIndexConfig = initContext.config.legacy.globalConfig$;
   }
 
   public async setup(
@@ -224,21 +217,24 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
 
     const usageCollection = plugins.usageCollection;
     if (usageCollection) {
+      registerActionsUsageCollector(
+        usageCollection,
+        core
+          .getStartServices()
+          .then(([_, { taskManager }]) => taskManager as TaskManagerStartContract)
+      );
+
       initializeActionsTelemetry(
         this.telemetryLogger,
         plugins.taskManager,
         core,
-        await this.kibanaIndex
+        this.kibanaIndexConfig
       );
-
-      core.getStartServices().then(async ([, startPlugins]) => {
-        registerActionsUsageCollector(usageCollection, startPlugins.taskManager);
-      });
     }
 
     core.http.registerRouteHandlerContext(
       'actions',
-      this.createRouteHandlerContext(core, await this.kibanaIndex)
+      this.createRouteHandlerContext(core, this.kibanaIndexConfig)
     );
 
     // Routes
@@ -273,7 +269,7 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
       actionExecutor,
       actionTypeRegistry,
       taskRunnerFactory,
-      kibanaIndex,
+      kibanaIndexConfig,
       isESOUsingEphemeralEncryptionKey,
       preconfiguredActions,
       instantiateAuthorization,
@@ -301,10 +297,12 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
         request
       );
 
+      const kibanaIndex = (await kibanaIndexConfig.pipe(first()).toPromise()).kibana.index;
+
       return new ActionsClient({
         unsecuredSavedObjectsClient,
         actionTypeRegistry: actionTypeRegistry!,
-        defaultKibanaIndex: await kibanaIndex,
+        defaultKibanaIndex: kibanaIndex,
         scopedClusterClient: core.elasticsearch.legacy.client.asScoped(request),
         preconfiguredActions,
         request,
@@ -430,7 +428,7 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
 
   private createRouteHandlerContext = (
     core: CoreSetup<ActionsPluginsStart>,
-    defaultKibanaIndex: string
+    config: Observable<{ kibana: { index: string } }>
   ): IContextProvider<RequestHandler<unknown, unknown, unknown>, 'actions'> => {
     const {
       actionTypeRegistry,
@@ -442,6 +440,8 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
 
     return async function actionsRouteHandlerContext(context, request) {
       const [{ savedObjects }, { taskManager }] = await core.getStartServices();
+      const defaultKibanaIndex = (await config.pipe(first()).toPromise()).kibana.index;
+
       return {
         getActionsClient: () => {
           if (isESOUsingEphemeralEncryptionKey === true) {

x-pack/plugins/actions/server/usage/actions_usage_collector.ts

@@ -26,11 +26,16 @@ const byTypeSchema: MakeSchemaFrom<ActionsUsage>['count_by_type'] = {
 
 export function createActionsUsageCollector(
   usageCollection: UsageCollectionSetup,
-  taskManager: TaskManagerStartContract
+  taskManager: Promise<TaskManagerStartContract>
 ) {
+  let isCollectorReady = false;
+  taskManager.then(() => {
+    // mark lensUsageCollector as ready to collect when the TaskManager is ready
+    isCollectorReady = true;
+  });
   return usageCollection.makeUsageCollector<ActionsUsage>({
     type: 'actions',
-    isReady: () => true,
+    isReady: () => isCollectorReady,
     schema: {
       count_total: { type: 'long' },
       count_active_total: { type: 'long' },
@@ -79,7 +84,7 @@ async function getLatestTaskState(taskManager: TaskManagerStartContract) {
 
 export function registerActionsUsageCollector(
   usageCollection: UsageCollectionSetup,
-  taskManager: TaskManagerStartContract
+  taskManager: Promise<TaskManagerStartContract>
 ) {
   const collector = createActionsUsageCollector(usageCollection, taskManager);
   usageCollection.registerCollector(collector);

x-pack/plugins/actions/server/usage/task.ts

@@ -6,6 +6,8 @@
 
 import { Logger, CoreSetup, LegacyAPICaller } from 'kibana/server';
 import moment from 'moment';
+import { first } from 'rxjs/operators';
+import { Observable } from 'rxjs';
 import {
   RunContext,
   TaskManagerSetupContract,
@@ -21,9 +23,9 @@ export function initializeActionsTelemetry(
   logger: Logger,
   taskManager: TaskManagerSetupContract,
   core: CoreSetup,
-  kibanaIndex: string
+  config: Observable<{ kibana: { index: string } }>
 ) {
-  registerActionsTelemetryTask(logger, taskManager, core, kibanaIndex);
+  registerActionsTelemetryTask(logger, taskManager, core, config);
 }
 
 export function scheduleActionsTelemetry(logger: Logger, taskManager: TaskManagerStartContract) {
@@ -34,13 +36,13 @@ function registerActionsTelemetryTask(
   logger: Logger,
   taskManager: TaskManagerSetupContract,
   core: CoreSetup,
-  kibanaIndex: string
+  config: Observable<{ kibana: { index: string } }>
 ) {
   taskManager.registerTaskDefinitions({
     [TELEMETRY_TASK_TYPE]: {
       title: 'Actions usage fetch task',
       timeout: '5m',
-      createTaskRunner: telemetryTaskRunner(logger, core, kibanaIndex),
+      createTaskRunner: telemetryTaskRunner(logger, core, config),
     },
   });
 }
@@ -58,7 +60,11 @@ async function scheduleTasks(logger: Logger, taskManager: TaskManagerStartContra
   }
 }
 
-export function telemetryTaskRunner(logger: Logger, core: CoreSetup, kibanaIndex: string) {
+export function telemetryTaskRunner(
+  logger: Logger,
+  core: CoreSetup,
+  config: Observable<{ kibana: { index: string } }>
+) {
   return ({ taskInstance }: RunContext) => {
     const { state } = taskInstance;
     const callCluster = (...args: Parameters<LegacyAPICaller>) => {
@@ -68,6 +74,7 @@ export function telemetryTaskRunner(logger: Logger, core: CoreSetup, kibanaIndex
     };
     return {
       async run() {
+        const kibanaIndex = (await config.pipe(first()).toPromise()).kibana.index;
         return Promise.all([
           getTotalCount(callCluster, kibanaIndex),
           getInUseTotalCount(callCluster, kibanaIndex),

x-pack/plugins/alerts/server/plugin.ts

@@ -5,6 +5,7 @@
  */
 import type { PublicMethodsOf } from '@kbn/utility-types';
 import { first, map } from 'rxjs/operators';
+import { Observable } from 'rxjs';
 import { UsageCollectionSetup } from 'src/plugins/usage_collection/server';
 import { combineLatest } from 'rxjs';
 import { SecurityPluginSetup } from '../../security/server';
@@ -126,30 +127,25 @@ export class AlertingPlugin {
   private security?: SecurityPluginSetup;
   private readonly alertsClientFactory: AlertsClientFactory;
   private readonly telemetryLogger: Logger;
-  private readonly kibanaIndex: Promise<string>;
   private readonly kibanaVersion: PluginInitializerContext['env']['packageInfo']['version'];
   private eventLogService?: IEventLogService;
   private eventLogger?: IEventLogger;
+  private readonly kibanaIndexConfig: Observable<{ kibana: { index: string } }>;
 
   constructor(initializerContext: PluginInitializerContext) {
     this.config = initializerContext.config.create<AlertsConfig>().pipe(first()).toPromise();
     this.logger = initializerContext.logger.get('plugins', 'alerting');
     this.taskRunnerFactory = new TaskRunnerFactory();
     this.alertsClientFactory = new AlertsClientFactory();
     this.telemetryLogger = initializerContext.logger.get('usage');
-    this.kibanaIndex = initializerContext.config.legacy.globalConfig$
-      .pipe(
-        first(),
-        map((config: SharedGlobalConfig) => config.kibana.index)
-      )
-      .toPromise();
+    this.kibanaIndexConfig = initializerContext.config.legacy.globalConfig$;
     this.kibanaVersion = initializerContext.env.packageInfo.version;
   }
 
-  public async setup(
+  public setup(
     core: CoreSetup<AlertingPluginsStart, unknown>,
     plugins: AlertingPluginsSetup
-  ): Promise<PluginSetupContract> {
+  ): PluginSetupContract {
     this.licenseState = new LicenseState(plugins.licensing.license$);
     this.spaces = plugins.spaces?.spacesService;
     this.security = plugins.security;
@@ -192,16 +188,19 @@ export class AlertingPlugin {
 
     const usageCollection = plugins.usageCollection;
     if (usageCollection) {
+      registerAlertsUsageCollector(
+        usageCollection,
+        core
+          .getStartServices()
+          .then(([_, { taskManager }]) => taskManager as TaskManagerStartContract)
+      );
+
       initializeAlertingTelemetry(
         this.telemetryLogger,
         core,
         plugins.taskManager,
-        await this.kibanaIndex
+        this.kibanaIndexConfig
       );
-
-      core.getStartServices().then(async ([, startPlugins]) => {
-        registerAlertsUsageCollector(usageCollection, startPlugins.taskManager);
-      });
     }
 
     initializeApiKeyInvalidator(

x-pack/plugins/alerts/server/usage/alerts_usage_collector.ts

@@ -44,11 +44,16 @@ const byTypeSchema: MakeSchemaFrom<AlertsUsage>['count_by_type'] = {
 
 export function createAlertsUsageCollector(
   usageCollection: UsageCollectionSetup,
-  taskManager: TaskManagerStartContract
+  taskManager: Promise<TaskManagerStartContract>
 ) {
+  let isCollectorReady = false;
+  taskManager.then(() => {
+    // mark lensUsageCollector as ready to collect when the TaskManager is ready
+    isCollectorReady = true;
+  });
   return usageCollection.makeUsageCollector<AlertsUsage>({
     type: 'alerts',
-    isReady: () => true,
+    isReady: () => isCollectorReady,
     fetch: async () => {
       try {
         const doc = await getLatestTaskState(await taskManager);
@@ -129,7 +134,7 @@ async function getLatestTaskState(taskManager: TaskManagerStartContract) {
 
 export function registerAlertsUsageCollector(
   usageCollection: UsageCollectionSetup,
-  taskManager: TaskManagerStartContract
+  taskManager: Promise<TaskManagerStartContract>
 ) {
   const collector = createAlertsUsageCollector(usageCollection, taskManager);
   usageCollection.registerCollector(collector);

x-pack/plugins/alerts/server/usage/task.ts

@@ -6,6 +6,8 @@
 
 import { Logger, CoreSetup, LegacyAPICaller } from 'kibana/server';
 import moment from 'moment';
+import { first } from 'rxjs/operators';
+import { Observable } from 'rxjs';
 import {
   RunContext,
   TaskManagerSetupContract,
@@ -22,9 +24,9 @@ export function initializeAlertingTelemetry(
   logger: Logger,
   core: CoreSetup,
   taskManager: TaskManagerSetupContract,
-  kibanaIndex: string
+  config: Observable<{ kibana: { index: string } }>
 ) {
-  registerAlertingTelemetryTask(logger, core, taskManager, kibanaIndex);
+  registerAlertingTelemetryTask(logger, core, taskManager, config);
 }
 
 export function scheduleAlertingTelemetry(logger: Logger, taskManager?: TaskManagerStartContract) {
@@ -37,13 +39,13 @@ function registerAlertingTelemetryTask(
   logger: Logger,
   core: CoreSetup,
   taskManager: TaskManagerSetupContract,
-  kibanaIndex: string
+  config: Observable<{ kibana: { index: string } }>
 ) {
   taskManager.registerTaskDefinitions({
     [TELEMETRY_TASK_TYPE]: {
       title: 'Alerting usage fetch task',
       timeout: '5m',
-      createTaskRunner: telemetryTaskRunner(logger, core, kibanaIndex),
+      createTaskRunner: telemetryTaskRunner(logger, core, config),
     },
   });
 }
@@ -61,7 +63,11 @@ async function scheduleTasks(logger: Logger, taskManager: TaskManagerStartContra
   }
 }
 
-export function telemetryTaskRunner(logger: Logger, core: CoreSetup, kibanaIndex: string) {
+export function telemetryTaskRunner(
+  logger: Logger,
+  core: CoreSetup,
+  config: Observable<{ kibana: { index: string } }>
+) {
   return ({ taskInstance }: RunContext) => {
     const { state } = taskInstance;
     const callCluster = (...args: Parameters<LegacyAPICaller>) => {
@@ -72,6 +78,7 @@ export function telemetryTaskRunner(logger: Logger, core: CoreSetup, kibanaIndex
 
     return {
       async run() {
+        const kibanaIndex = (await config.pipe(first()).toPromise()).kibana.index;
         return Promise.all([
           getTotalCountAggregations(callCluster, kibanaIndex),
           getTotalCountInUse(callCluster, kibanaIndex),