Adds telemetry support to alerting and actions plugins

x-pack/plugins/actions/kibana.json

@@ -5,6 +5,6 @@
   "kibanaVersion": "kibana",
   "configPath": ["xpack", "actions"],
   "requiredPlugins": ["licensing", "taskManager", "encryptedSavedObjects", "eventLog"],
-  "optionalPlugins": ["spaces"],
+  "optionalPlugins": ["usageCollection", "spaces"],
   "ui": false
 }

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

@@ -11,8 +11,13 @@ import { licensingMock } from '../../licensing/server/mocks';
 import { encryptedSavedObjectsMock } from '../../encrypted_saved_objects/server/mocks';
 import { taskManagerMock } from '../../task_manager/server/mocks';
 import { eventLogMock } from '../../event_log/server/mocks';
+import { UsageCollectionSetup } from 'src/plugins/usage_collection/server';
 
 describe('Actions Plugin', () => {
+  const usageCollectionMock: jest.Mocked<UsageCollectionSetup> = ({
+    makeUsageCollector: jest.fn(),
+    registerCollector: jest.fn(),
+  } as unknown) as jest.Mocked<UsageCollectionSetup>;
   describe('setup()', () => {
     let context: PluginInitializerContext;
     let plugin: ActionsPlugin;
@@ -23,11 +28,13 @@ describe('Actions Plugin', () => {
       context = coreMock.createPluginInitializerContext();
       plugin = new ActionsPlugin(context);
       coreSetup = coreMock.createSetup();
+
       pluginsSetup = {
         taskManager: taskManagerMock.createSetup(),
         encryptedSavedObjects: encryptedSavedObjectsMock.createSetup(),
         licensing: licensingMock.createSetup(),
         eventLog: eventLogMock.createSetup(),
+        usageCollection: usageCollectionMock,
       };
     });
 
@@ -108,6 +115,7 @@ describe('Actions Plugin', () => {
         encryptedSavedObjects: encryptedSavedObjectsMock.createSetup(),
         licensing: licensingMock.createSetup(),
         eventLog: eventLogMock.createSetup(),
+        usageCollection: usageCollectionMock,
       };
       pluginsStart = {
         taskManager: taskManagerMock.createStart(),

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

@@ -5,6 +5,7 @@
  */
 
 import { first, map } from 'rxjs/operators';
+import { UsageCollectionSetup } from 'src/plugins/usage_collection/server';
 import {
   PluginInitializerContext,
   Plugin,
@@ -35,6 +36,7 @@ import { ActionTypeRegistry } from './action_type_registry';
 import { ExecuteOptions } from './create_execute_function';
 import { createExecuteFunction } from './create_execute_function';
 import { registerBuiltInActionTypes } from './builtin_action_types';
+import { registerActionsUsageCollector } from './usage';
 
 import { getActionsConfigurationUtilities } from './actions_config';
 
@@ -49,6 +51,7 @@ import {
 } from './routes';
 import { LicenseState } from './lib/license_state';
 import { IEventLogger, IEventLogService } from '../../event_log/server';
+import { initializeActionsTelemetry, scheduleActionsTelemetry } from './usage/task';
 
 const EVENT_LOG_PROVIDER = 'actions';
 export const EVENT_LOG_ACTIONS = {
@@ -71,6 +74,7 @@ export interface ActionsPluginsSetup {
   licensing: LicensingPluginSetup;
   spaces?: SpacesPluginSetup;
   eventLog: IEventLogService;
+  usageCollection?: UsageCollectionSetup;
 }
 export interface ActionsPluginsStart {
   encryptedSavedObjects: EncryptedSavedObjectsPluginStart;
@@ -91,6 +95,7 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
   private spaces?: SpacesServiceSetup;
   private eventLogger?: IEventLogger;
   private isESOUsingEphemeralEncryptionKey?: boolean;
+  private readonly telemetryLogger: Logger;
 
   constructor(initContext: PluginInitializerContext) {
     this.config = initContext.config
@@ -106,6 +111,7 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
       .toPromise();
 
     this.logger = initContext.logger.get('actions');
+    this.telemetryLogger = initContext.logger.get('telemetry');
   }
 
   public async setup(core: CoreSetup, plugins: ActionsPluginsSetup): Promise<PluginSetupContract> {
@@ -140,6 +146,8 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
     const actionExecutor = new ActionExecutor({
       isESOUsingEphemeralEncryptionKey: this.isESOUsingEphemeralEncryptionKey,
     });
+
+    // get executions count
     const taskRunnerFactory = new TaskRunnerFactory(actionExecutor);
     const actionsConfigUtils = getActionsConfigurationUtilities(
       (await this.config) as ActionsConfig
@@ -162,6 +170,20 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
       actionsConfigUtils,
     });
 
+    const usageCollection = plugins.usageCollection;
+    if (usageCollection) {
+      core.getStartServices().then(async ([coreStart, startPlugins]: [CoreStart, any]) => {
+        registerActionsUsageCollector(usageCollection, startPlugins.taskManager);
+
+        initializeActionsTelemetry(
+          this.telemetryLogger,
+          plugins.taskManager,
+          core,
+          await this.kibanaIndex
+        );
+      });
+    }
+
     core.http.registerRouteHandlerContext(
       'actions',
       this.createRouteHandlerContext(await this.kibanaIndex)
@@ -211,6 +233,8 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
       getScopedSavedObjectsClient: core.savedObjects.getScopedClient,
     });
 
+    scheduleActionsTelemetry(this.telemetryLogger, plugins.taskManager);
+
     return {
       execute: createExecuteFunction({
         taskManager: plugins.taskManager,

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

@@ -0,0 +1,145 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { APICaller } from 'kibana/server';
+
+export async function getTotalCount(callCluster: APICaller, kibanaIndex: string) {
+  const scriptedMetric = {
+    scripted_metric: {
+      init_script: 'state.types = [:]',
+      map_script: `
+        String actionType = doc['action.actionTypeId'].value;
+        state.types.put(actionType, state.types.containsKey(actionType) ? state.types.get(actionType) + 1 : 1);
+      `,
+      // Combine script is executed per cluster, but we already have a key-value pair per cluster.
+      // Despite docs that say this is optional, this script can't be blank.
+      combine_script: 'return state',
+      // Reduce script is executed across all clusters, so we need to add up all the total from each cluster
+      // This also needs to account for having no data
+      reduce_script: `
+        Map result = [:];
+        for (Map m : states.toArray()) {
+          if (m !== null) {
+            for (String k : m.keySet()) {
+              result.put(k, result.containsKey(k) ? result.get(k) + m.get(k) : m.get(k));
+            }
+          }
+        }
+        return result;
+      `,
+    },
+  };
+
+  const searchResult = await callCluster('search', {
+    index: kibanaIndex,
+    rest_total_hits_as_int: true,
+    body: {
+      query: {
+        bool: {
+          filter: [{ term: { type: 'action' } }],
+        },
+      },
+      aggs: {
+        byActionTypeId: scriptedMetric,
+      },
+    },
+  });
+
+  return {
+    countTotal: Object.keys(searchResult.aggregations.byActionTypeId.value.types).reduce(
+      (total: number, key: string) =>
+        parseInt(searchResult.aggregations.byActionTypeId.value.types[key], 0) + total,
+      0
+    ),
+    countByType: searchResult.aggregations.byActionTypeId.value.types,
+  };
+}
+
+export async function getInUseTotalCount(callCluster: APICaller, kibanaIndex: string) {
+  const scriptedMetric = {
+    scripted_metric: {
+      init_script: 'state.connectorIds = new HashMap(); state.total = 0;',
+      map_script: `
+        String connectorId = doc['references.id'].value;
+        String actionRef = doc['references.name'].value;
+        if (state.connectorIds[connectorId] === null) {
+          state.connectorIds[connectorId] = actionRef;
+          state.total++;
+        }
+      `,
+      // Combine script is executed per cluster, but we already have a key-value pair per cluster.
+      // Despite docs that say this is optional, this script can't be blank.
+      combine_script: 'return state',
+      // Reduce script is executed across all clusters, so we need to add up all the total from each cluster
+      // This also needs to account for having no data
+      reduce_script: `
+          Map connectorIds = [:];
+          long total = 0;
+          for (state in states) {
+            if (state !== null) {
+              total += state.total;
+              for (String k : state.connectorIds.keySet()) {
+                connectorIds.put(k, connectorIds.containsKey(k) ? connectorIds.get(k) + state.connectorIds.get(k) : state.connectorIds.get(k));
+              }
+            }
+          }
+          Map result = new HashMap();
+          result.total = total;
+          result.connectorIds = connectorIds;
+          return result;
+      `,
+    },
+  };
+
+  const actionResults = await callCluster('search', {
+    index: kibanaIndex,
+    rest_total_hits_as_int: true,
+    body: {
+      query: {
+        bool: {
+          filter: {
+            bool: {
+              must: {
+                nested: {
+                  path: 'references',
+                  query: {
+                    bool: {
+                      filter: {
+                        bool: {
+                          must: [
+                            {
+                              term: {
+                                'references.type': 'action',
+                              },
+                            },
+                          ],
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      aggs: {
+        refs: {
+          nested: {
+            path: 'references',
+          },
+          aggs: {
+            actionRefIds: scriptedMetric,
+          },
+        },
+      },
+    },
+  });
+
+  return actionResults.aggregations.refs.actionRefIds.value.total;
+}
+
+// TODO: Implement executions count telemetry with eventLog, when it will write to index

x-pack/plugins/actions/server/usage/actions_usage_collector.test.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;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { UsageCollectionSetup } from 'src/plugins/usage_collection/server';
+import { registerActionsUsageCollector } from './actions_usage_collector';
+import { taskManagerMock } from '../../../task_manager/server/task_manager.mock';
+
+const mockTaskManagerStart = taskManagerMock.start();
+
+beforeEach(() => jest.resetAllMocks());
+
+describe('registerActionsUsageCollector', () => {
+  let usageCollectionMock: jest.Mocked<UsageCollectionSetup>;
+  beforeEach(() => {
+    usageCollectionMock = ({
+      makeUsageCollector: jest.fn(),
+      registerCollector: jest.fn(),
+    } as unknown) as jest.Mocked<UsageCollectionSetup>;
+  });
+
+  it('should call registerCollector', () => {
+    registerActionsUsageCollector(usageCollectionMock, mockTaskManagerStart);
+    expect(usageCollectionMock.registerCollector).toHaveBeenCalledTimes(1);
+  });
+
+  it('should call makeUsageCollector with type = actions', () => {
+    registerActionsUsageCollector(usageCollectionMock, mockTaskManagerStart);
+    expect(usageCollectionMock.makeUsageCollector).toHaveBeenCalledTimes(1);
+    expect(usageCollectionMock.makeUsageCollector.mock.calls[0][0].type).toBe('actions');
+  });
+});

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

@@ -0,0 +1,65 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { UsageCollectionSetup } from 'src/plugins/usage_collection/server';
+import { get } from 'lodash';
+import { TaskManagerStartContract } from '../../../task_manager/server';
+import { ActionsUsage } from './types';
+
+export function createActionsUsageCollector(
+  usageCollection: UsageCollectionSetup,
+  taskManager: TaskManagerStartContract
+) {
+  return usageCollection.makeUsageCollector({
+    type: 'actions',
+    isReady: () => true,
+    fetch: async (): Promise<ActionsUsage> => {
+      try {
+        const doc = await getLatestTaskState(await taskManager);
+        // get the accumulated state from the recurring task
+        const state: ActionsUsage = get(doc, 'state');
+
+        return {
+          ...state,
+        };
+      } catch (err) {
+        return {
+          count_total: 0,
+          count_active_total: 0,
+          count_active_by_type: {},
+          count_by_type: {},
+        };
+      }
+    },
+  });
+}
+
+async function getLatestTaskState(taskManager: TaskManagerStartContract) {
+  try {
+    const result = await taskManager.get('Actions-actions_telemetry');
+    return result;
+  } 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.includes('NotInitialized')) {
+      throw err;
+    }
+  }
+
+  return null;
+}
+
+export function registerActionsUsageCollector(
+  usageCollection: UsageCollectionSetup,
+  taskManager: TaskManagerStartContract
+) {
+  const collector = createActionsUsageCollector(usageCollection, taskManager);
+  usageCollection.registerCollector(collector);
+}

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

@@ -0,0 +1,7 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+export { registerActionsUsageCollector } from './actions_usage_collector';