Extended existing alerting functionality to support preconfigured onl…

…y action types (#64030)

* Extended existing alerting functionality to support preconfigured only action types

* fixed functional test

* Adding documentation

* Fixed UI part due to comments

* added missing tests

* fixed action type execution

* Fixed documentation

* Fixed due to comments

* fixed type checks

* extended isActionExecutable to check exact action id if it is in the preconfigured list

docs/user/alerting/action-types.asciidoc

@@ -41,16 +41,19 @@ see https://www.elastic.co/subscriptions[the subscription page].
 
 [float]
 [[create-connectors]]
-=== Connectors
+=== Preconfigured connectors and action types
 
 You can create connectors for actions in <<managing-alerts-and-actions, Alerts and Actions>> or via the action API.
 For out-of-the-box and standardized connectors, you can <<pre-configured-connectors, preconfigure connectors>>
 before {kib} starts.
 
+Action type with only preconfigured connectors could be specified as a <<pre-configured-action-types, preconfigured action type>>.
+
 include::action-types/email.asciidoc[]
 include::action-types/index.asciidoc[]
 include::action-types/pagerduty.asciidoc[]
 include::action-types/server-log.asciidoc[]
 include::action-types/slack.asciidoc[]
 include::action-types/webhook.asciidoc[]
 include::pre-configured-connectors.asciidoc[]
+include::pre-configured-action-types.asciidoc[]

docs/user/alerting/pre-configured-action-types.asciidoc

@@ -0,0 +1,61 @@
+[role="xpack"]
+[[pre-configured-action-types]]
+
+== Preconfigured action types
+
+A preconfigure an action type has all the information it needs prior to startup.
+A preconfigured action type offers the following capabilities:
+
+- Requires no setup. Configuration and credentials needed to execute an
+action are predefined.
+- Has only <<pre-configured-connectors, preconfigured connectors>>.
+- Connectors of the preconfigured action type cannot be edited or deleted.
+
+[float]
+[[preconfigured-action-type-example]]
+=== Creating a preconfigured action
+
+In the `kibana.yml` file:
+
+. Exclude the action type from `xpack.actions.enabledActionTypes`.
+. Add all its connectors.
+
+The following example shows a valid configuration of preconfigured action type with one out-of-the box connector.
+
+```js
+ xpack.actions.enabledActionTypes: ['.slack', '.email', '.index'] <1>
+ xpack.actions.preconfigured: <2>
+ - id: 'my-server-log'
+ actionTypeId: .server-log
+ name: 'Server log #xyz'
+```
+
+<1> `enabledActionTypes` should exclude preconfigured action type to prevent creating and deleting connectors.
+<2> `preconfigured` is the setting for defining the list of available connectors for the preconfigured action type.
+
+[float]
+[[pre-configured-action-type-alert-form]]
+=== Attaching a preconfigured action to an alert
+
+To attach an action to an alert,
+select from a list of available action types, and
+then select the *Server log* type. This action type was configured previously.
+
+[role="screenshot"]
+image::images/pre-configured-action-type-alert-form.png[Create alert with selected Server log action type]
+
+[float]
+[[managing-pre-configured-action-types]]
+=== Managing preconfigured actions
+
+Connectors with preconfigured actions appear in the connector list, regardless of which space the user is in.
+They are tagged as “preconfigured” and cannot be deleted.
+
+[role="screenshot"]
+image::images/pre-configured-action-type-managing.png[Connectors managing tab with pre-cofigured]
+
+Clicking *Create connector* shows the list of available action types.
+Preconfigured action types are not included because you can't create a connector with a preconfigured action type.
+
+[role="screenshot"]
+image::images/pre-configured-action-type-select-type.png[Pre-configured connector create menu]

x-pack/plugins/actions/server/action_type_registry.mock.ts

@@ -14,6 +14,7 @@ const createActionTypeRegistryMock = () => {
  list: jest.fn(),
  ensureActionTypeEnabled: jest.fn(),
  isActionTypeEnabled: jest.fn(),
+ isActionExecutable: jest.fn(),
  };
  return mocked;
 };

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

@@ -28,6 +28,16 @@ beforeEach(() => {
  ),
  actionsConfigUtils: mockedActionsConfig,
  licenseState: mockedLicenseState,
+ preconfiguredActions: [
+ {
+ actionTypeId: 'foo',
+ config: {},
+ id: 'my-slack1',
+ name: 'Slack #xyz',
+ secrets: {},
+ isPreconfigured: true,
+ },
+ ],
  };
 });
 
@@ -194,6 +204,19 @@ describe('isActionTypeEnabled', () => {
  expect(mockedActionsConfig.isActionTypeEnabled).toHaveBeenCalledWith('foo');
  });
 
+ test('should call isActionExecutable of the actions config', async () => {
+ mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
+ actionTypeRegistry.isActionExecutable('my-slack1', 'foo');
+ expect(mockedActionsConfig.isActionTypeEnabled).toHaveBeenCalledWith('foo');
+ });
+
+ test('should return true when isActionTypeEnabled is false and isLicenseValidForActionType is true and it has preconfigured connectors', async () => {
+ mockedActionsConfig.isActionTypeEnabled.mockReturnValue(false);
+ mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
+
+ expect(actionTypeRegistry.isActionExecutable('my-slack1', 'foo')).toEqual(true);
+ });
+
  test('should call isLicenseValidForActionType of the license state', async () => {
  mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
  actionTypeRegistry.isActionTypeEnabled('foo');

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

@@ -8,7 +8,7 @@ import Boom from 'boom';
 import { i18n } from '@kbn/i18n';
 import { RunContext, TaskManagerSetupContract } from '../../task_manager/server';
 import { ExecutorError, TaskRunnerFactory, ILicenseState } from './lib';
-import { ActionType } from './types';
+import { ActionType, PreConfiguredAction } from './types';
 import { ActionType as CommonActionType } from '../common';
 import { ActionsConfigurationUtilities } from './actions_config';
 
@@ -17,6 +17,7 @@ export interface ActionTypeRegistryOpts {
  taskRunnerFactory: TaskRunnerFactory;
  actionsConfigUtils: ActionsConfigurationUtilities;
  licenseState: ILicenseState;
+ preconfiguredActions: PreConfiguredAction[];
 }
 
 export class ActionTypeRegistry {
@@ -25,12 +26,14 @@ export class ActionTypeRegistry {
  private readonly taskRunnerFactory: TaskRunnerFactory;
  private readonly actionsConfigUtils: ActionsConfigurationUtilities;
  private readonly licenseState: ILicenseState;
+ private readonly preconfiguredActions: PreConfiguredAction[];
 
  constructor(constructorParams: ActionTypeRegistryOpts) {
  this.taskManager = constructorParams.taskManager;
  this.taskRunnerFactory = constructorParams.taskRunnerFactory;
  this.actionsConfigUtils = constructorParams.actionsConfigUtils;
  this.licenseState = constructorParams.licenseState;
+ this.preconfiguredActions = constructorParams.preconfiguredActions;
  }
 
  /**
@@ -58,6 +61,19 @@ export class ActionTypeRegistry {
  );
  }
 
+ /**
+ * Returns true if action type is enabled or it is a preconfigured action type.
+ */
+ public isActionExecutable(actionId: string, actionTypeId: string) {
+ return (
+ this.isActionTypeEnabled(actionTypeId) ||
+ (!this.isActionTypeEnabled(actionTypeId) &&
+ this.preconfiguredActions.find(
+ preconfiguredAction => preconfiguredAction.id === actionId
+ ) !== undefined)
+ );
+ }
+
  /**
  * Registers an action type to the action type registry
  */

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

@@ -44,6 +44,7 @@ beforeEach(() => {
  ),
  actionsConfigUtils: actionsConfigMock.create(),
  licenseState: mockedLicenseState,
+ preconfiguredActions: [],
  };
  actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
  actionsClient = new ActionsClient({
@@ -221,6 +222,7 @@ describe('create()', () => {
  ),
  actionsConfigUtils: localConfigUtils,
  licenseState: licenseStateMock.create(),
+ preconfiguredActions: [],
  };
 
  actionTypeRegistry = new ActionTypeRegistry(localActionTypeRegistryParams);

x-pack/plugins/actions/server/builtin_action_types/index.test.ts

@@ -27,6 +27,7 @@ export function createActionTypeRegistry(): {
  ),
  actionsConfigUtils: actionsConfigMock.create(),
  licenseState: licenseStateMock.create(),
+ preconfiguredActions: [],
  });
  registerBuiltInActionTypes({
  logger,

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

@@ -282,4 +282,65 @@ describe('execute()', () => {
  })
  ).rejects.toThrowErrorMatchingInlineSnapshot(`"Fail"`);
  });
+
+ test('should skip ensure action type if action type is preconfigured and license is valid', async () => {
+ const mockedActionTypeRegistry = actionTypeRegistryMock.create();
+ const getScopedSavedObjectsClient = jest.fn().mockReturnValueOnce(savedObjectsClient);
+ const executeFn = createExecuteFunction({
+ getBasePath,
+ taskManager: mockTaskManager,
+ getScopedSavedObjectsClient,
+ isESOUsingEphemeralEncryptionKey: false,
+ actionTypeRegistry: mockedActionTypeRegistry,
+ preconfiguredActions: [
+ {
+ actionTypeId: 'mock-action',
+ config: {},
+ id: 'my-slack1',
+ name: 'Slack #xyz',
+ secrets: {},
+ isPreconfigured: true,
+ },
+ ],
+ });
+ mockedActionTypeRegistry.ensureActionTypeEnabled.mockImplementation(() => {
+ throw new Error('Fail');
+ });
+ mockedActionTypeRegistry.isActionExecutable.mockImplementation(() => true);
+ savedObjectsClient.get.mockResolvedValueOnce({
+ id: '123',
+ type: 'action',
+ attributes: {
+ actionTypeId: 'mock-action',
+ },
+ references: [],
+ });
+ savedObjectsClient.create.mockResolvedValueOnce({
+ id: '234',
+ type: 'action_task_params',
+ attributes: {},
+ references: [],
+ });
+
+ await executeFn({
+ id: '123',
+ params: { baz: false },
+ spaceId: 'default',
+ apiKey: null,
+ });
+ expect(getScopedSavedObjectsClient).toHaveBeenCalledWith({
+ getBasePath: expect.anything(),
+ headers: {},
+ path: '/',
+ route: { settings: {} },
+ url: {
+ href: '/',
+ },
+ raw: {
+ req: {
+ url: '/',
+ },
+ },
+ });
+ });
 });

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

@@ -70,7 +70,9 @@ export function createExecuteFunction({
  const savedObjectsClient = getScopedSavedObjectsClient(fakeRequest as KibanaRequest);
  const actionTypeId = await getActionTypeId(id);
 
- actionTypeRegistry.ensureActionTypeEnabled(actionTypeId);
+ if (!actionTypeRegistry.isActionExecutable(id, actionTypeId)) {
+ actionTypeRegistry.ensureActionTypeEnabled(actionTypeId);
+ }
 
  const actionTaskParamsRecord = await savedObjectsClient.create('action_task_params', {
  actionId: id,

x-pack/plugins/actions/server/lib/action_executor.test.ts

@@ -224,6 +224,50 @@ test('throws an error if actionType is not enabled', async () => {
  expect(actionTypeRegistry.ensureActionTypeEnabled).toHaveBeenCalledWith('test');
 });
 
+test('should not throws an error if actionType is preconfigured', async () => {
+ const actionType: jest.Mocked<ActionType> = {
+ id: 'test',
+ name: 'Test',
+ minimumLicenseRequired: 'basic',
+ executor: jest.fn(),
+ };
+ const actionSavedObject = {
+ id: '1',
+ type: 'action',
+ attributes: {
+ actionTypeId: 'test',
+ config: {
+ bar: true,
+ },
+ secrets: {
+ baz: true,
+ },
+ },
+ references: [],
+ };
+ savedObjectsClient.get.mockResolvedValueOnce(actionSavedObject);
+ encryptedSavedObjectsPlugin.getDecryptedAsInternalUser.mockResolvedValueOnce(actionSavedObject);
+ actionTypeRegistry.get.mockReturnValueOnce(actionType);
+ actionTypeRegistry.ensureActionTypeEnabled.mockImplementationOnce(() => {
+ throw new Error('not enabled for test');
+ });
+ actionTypeRegistry.isActionExecutable.mockImplementationOnce(() => true);
+ await actionExecutor.execute(executeParams);
+
+ expect(actionTypeRegistry.ensureActionTypeEnabled).toHaveBeenCalledTimes(0);
+ expect(actionType.executor).toHaveBeenCalledWith({
+ actionId: '1',
+ services: expect.anything(),
+ config: {
+ bar: true,
+ },
+ secrets: {
+ baz: true,
+ },
+ params: { foo: true },
+ });
+});
+
 test('throws an error when passing isESOUsingEphemeralEncryptionKey with value of true', async () => {
  const customActionExecutor = new ActionExecutor({ isESOUsingEphemeralEncryptionKey: true });
  customActionExecutor.initialize({

x-pack/plugins/actions/server/lib/action_executor.ts

@@ -90,7 +90,9 @@ export class ActionExecutor {
  namespace.namespace
  );
 
- actionTypeRegistry.ensureActionTypeEnabled(actionTypeId);
+ if (!actionTypeRegistry.isActionExecutable(actionId, actionTypeId)) {
+ actionTypeRegistry.ensureActionTypeEnabled(actionTypeId);
+ }
  const actionType = actionTypeRegistry.get(actionTypeId);
 
  let validatedParams: Record<string, unknown>;

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

@@ -20,6 +20,7 @@ const createStartMock = () => {
  const mock: jest.Mocked<PluginStartContract> = {
  execute: jest.fn(),
  isActionTypeEnabled: jest.fn(),
+ isActionExecutable: jest.fn(),
  getActionsClientWithRequest: jest.fn().mockResolvedValue(actionsClientMock.create()),
  preconfiguredActions: [],
  };

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

@@ -65,6 +65,7 @@ export interface PluginSetupContract {
 
 export interface PluginStartContract {
  isActionTypeEnabled(id: string): boolean;
+ isActionExecutable(actionId: string, actionTypeId: string): boolean;
  execute(options: ExecuteOptions): Promise<void>;
  getActionsClientWithRequest(request: KibanaRequest): Promise<PublicMethodsOf<ActionsClient>>;
  preconfiguredActions: PreConfiguredAction[];
@@ -170,6 +171,7 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
  taskManager: plugins.taskManager,
  actionsConfigUtils,
  licenseState: this.licenseState,
+ preconfiguredActions: this.preconfiguredActions,
  });
  this.taskRunnerFactory = taskRunnerFactory;
  this.actionTypeRegistry = actionTypeRegistry;
@@ -271,6 +273,9 @@ export class ActionsPlugin implements Plugin<Promise<PluginSetupContract>, Plugi
  isActionTypeEnabled: id => {
  return this.actionTypeRegistry!.isActionTypeEnabled(id);
  },
+ isActionExecutable: (actionId: string, actionTypeId: string) => {
+ return this.actionTypeRegistry!.isActionExecutable(actionId, actionTypeId);
+ },
  // Ability to get an actions client from legacy code
  async getActionsClientWithRequest(request: KibanaRequest) {
  if (isESOUsingEphemeralEncryptionKey === true) {