From c555eff81e5e27fcd5a2a5bb26c5a4e06c704273 Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Mon, 2 Jun 2025 10:15:29 +0200 Subject: [PATCH 01/14] Add bulk get rules to rules client Use it in the bulk actions endpoint --- .../application/rule/methods/get/get_rule.ts | 71 +------ .../rule/methods/get/get_rules.test.ts | 161 ++++++++++++++++ .../application/rule/methods/get/get_rules.ts | 117 +++++++++++ .../application/rule/methods/get/index.ts | 2 + .../get/schemas/get_rules_params_schema.ts | 15 ++ .../rule/methods/get/schemas/index.ts | 1 + .../methods/get/types/get_rules_params.ts | 11 ++ .../methods/get/types/get_rules_response.ts | 14 ++ .../rule/methods/get/types/index.ts | 1 + .../rule/methods/get/utils.test.ts | 182 ++++++++++++++++++ .../application/rule/methods/get/utils.ts | 72 +++++++ .../shared/alerting/server/data/rule/index.ts | 2 + .../data/rule/methods/bulk_get_rules_so.ts | 31 +++ .../alerting/server/rules_client.mock.ts | 1 + .../server/rules_client/rules_client.mock.ts | 7 +- .../server/rules_client/rules_client.ts | 6 +- .../fetch_rules_by_query_or_ids.ts | 32 +-- .../api/rules/bulk_actions/route.test.ts | 15 +- .../api/rules/bulk_actions/route.ts | 1 - 19 files changed, 653 insertions(+), 89 deletions(-) create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.test.ts create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.ts create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/get_rules_params_schema.ts create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_params.ts create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_response.ts create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/utils.test.ts create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/utils.ts create mode 100644 x-pack/platform/plugins/shared/alerting/server/data/rule/methods/bulk_get_rules_so.ts diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rule.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rule.ts index cd7868b9243d7..259ed73a09de7 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rule.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rule.ts @@ -6,41 +6,29 @@ */ import Boom from '@hapi/boom'; -import { AlertConsumers } from '@kbn/rule-data-utils'; -import type { - SanitizedRule, - SanitizedRuleWithLegacyId, - Rule as DeprecatedRule, -} from '../../../../types'; -import { ReadOperations, AlertingAuthorizationEntity } from '../../../../authorization'; -import { ruleAuditEvent, RuleAuditAction } from '../../../../rules_client/common/audit_events'; +import { AlertingAuthorizationEntity, ReadOperations } from '../../../../authorization'; +import { getRuleSo } from '../../../../data/rule'; +import { RuleAuditAction, ruleAuditEvent } from '../../../../rules_client/common/audit_events'; import type { RulesClientContext } from '../../../../rules_client/types'; -import { formatLegacyActions } from '../../../../rules_client/lib'; import { RULE_SAVED_OBJECT_TYPE } from '../../../../saved_objects'; -import type { GetRuleParams } from './types'; -import { getRuleParamsSchema } from './schemas'; -import { getRuleSo } from '../../../../data/rule'; -import { transformRuleAttributesToRuleDomain, transformRuleDomainToRule } from '../../transforms'; +import type { SanitizedRule, SanitizedRuleWithLegacyId } from '../../../../types'; import type { RuleParams } from '../../types'; -import { ruleDomainSchema } from '../../schemas'; +import { getRuleParamsSchema } from './schemas'; +import type { GetRuleParams } from './types'; +import { transformToSanitizedRule } from './utils'; export async function getRule( context: RulesClientContext, params: GetRuleParams ): Promise | SanitizedRuleWithLegacyId> { - const { - id, - includeLegacyId = false, - includeSnoozeData = false, - excludeFromPublicApi = false, - } = params; - try { getRuleParamsSchema.validate(params); } catch (error) { throw Boom.badRequest(`Error validating get data - ${error.message}`); } + const { id } = params; + const result = await getRuleSo({ savedObjectsClient: context.unsecuredSavedObjectsClient, id, @@ -70,44 +58,5 @@ export async function getRule( }) ); - const ruleType = context.ruleTypeRegistry.get(result.attributes.alertTypeId); - - const ruleDomain = transformRuleAttributesToRuleDomain( - result.attributes, - { - id: result.id, - logger: context.logger, - ruleType, - references: result.references, - includeSnoozeData, - }, - context.isSystemAction - ); - - // Try to validate created rule, but don't throw. - try { - ruleDomainSchema.validate(ruleDomain); - } catch (e) { - context.logger.warn(`Error validating get rule domain object for id: ${id}, ${e}`); - } - - // Convert domain rule to rule (Remove certain properties) - const rule = transformRuleDomainToRule(ruleDomain, { - isPublic: excludeFromPublicApi, - includeLegacyId, - }); - - // format legacy actions for SIEM rules - if (result.attributes.consumer === AlertConsumers.SIEM) { - const [migratedRule] = await formatLegacyActions([rule as DeprecatedRule], { - savedObjectsClient: context.unsecuredSavedObjectsClient, - logger: context.logger, - }); - - return migratedRule; - } - - // TODO (http-versioning): Remove this cast, this enables us to move forward - // without fixing all of other solution types - return rule as SanitizedRule; + return transformToSanitizedRule(context, result, params); } diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.test.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.test.ts new file mode 100644 index 0000000000000..ed147b2a556a8 --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.test.ts @@ -0,0 +1,161 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import Boom from '@hapi/boom'; +import { transformToSanitizedRule } from './utils'; +import { bulkGetRulesSo } from '../../../../data/rule'; +import { getRules } from './get_rules'; +import { rulesClientContextMock } from '../../../../rules_client/rules_client.mock'; +import type { GetRulesResponse } from './types/get_rules_response'; +import type { RuleParams } from '../../types'; +import { RuleAuditAction } from '../../../../rules_client/common/audit_events'; +import type { GetRulesParams } from './types'; + +jest.mock('./utils', () => { + return { + transformToSanitizedRule: jest.fn(), + }; +}); + +jest.mock('../../../../data/rule', () => { + return { + bulkGetRulesSo: jest.fn(), + }; +}); + +const rulesClientContext = rulesClientContextMock.create(); +const transformToSanitizedRuleMock = transformToSanitizedRule as jest.Mock; +const bulkGetRulesSoMock = bulkGetRulesSo as jest.Mock; +const ensureAuthorizedMock = rulesClientContext.authorization.ensureAuthorized as jest.Mock; +const auditLoggerMock = rulesClientContext.auditLogger?.log as jest.Mock; + +const getRule = (id: string, alertTypeId: string, consumer: string) => ({ + id, + attributes: { name: `rule-so-${id}`, alertTypeId, consumer }, +}); +const getRuleErroredFetchingSo = (id: string) => ({ id, error: { message: `rule ${id} errored` } }); +const getTestRules = () => { + const successful = [ + getRule('1', 'some-alert-type-1', 'some-consumer-1'), + getRule('2', 'some-alert-type-1', 'some-consumer-2'), + getRule('3', 'some-alert-type-2', 'some-consumer-1'), + getRule('4', 'some-alert-type-2', 'some-consumer-1'), + ]; + + const erroredFetchingSo = [getRuleErroredFetchingSo('5')]; + + const erroredAccess = [getRule('6', 'some-forbidden-alert-type', 'some-consumer-1')]; + + return { + successful, + erroredFetchingSo, + erroredAccess, + all: [...successful, ...erroredFetchingSo, ...erroredAccess], + }; +}; + +describe('getRules', () => { + let ruleIds: string[] = []; + let results: GetRulesResponse; + let testRules: ReturnType; + beforeEach(async () => { + jest.resetAllMocks(); + testRules = getTestRules(); + ruleIds = testRules.all.map(({ id }) => id); + transformToSanitizedRuleMock.mockImplementation((_, rule) => { + return { + ...rule, + sanitized: true, + }; + }); + + bulkGetRulesSoMock.mockResolvedValueOnce({ + saved_objects: testRules.all, + }); + + ensureAuthorizedMock.mockImplementation(async ({ ruleTypeId, consumer }) => { + const errorRule = testRules.erroredAccess.find( + (rule) => + rule.attributes.alertTypeId === ruleTypeId && rule.attributes.consumer === consumer + ); + if (errorRule) { + throw Boom.forbidden('Unauthorized'); + } + }); + + results = await getRules(rulesClientContext, { ids: ruleIds }); + }); + + it('should throw if called with invalid params', async () => { + await expect( + getRules(rulesClientContext, {} as unknown as GetRulesParams) + ).rejects.toThrowErrorMatchingInlineSnapshot( + '"Error validating get rules params - [ids]: expected value of type [array] but got [undefined]"' + ); + }); + + it('should attempt to resolve rules', () => { + expect(bulkGetRulesSoMock).toHaveBeenCalledTimes(1); + expect(bulkGetRulesSoMock).toHaveBeenCalledWith({ + savedObjectsClient: rulesClientContext.unsecuredSavedObjectsClient, + ids: ruleIds, + }); + }); + + it('should audit log', () => { + expect(auditLoggerMock).toHaveBeenCalledTimes(6); + const assertAuditLogCall = (id: string, name?: string, errorMsg?: string) => { + const errorObj = errorMsg ? expect.objectContaining({ message: errorMsg }) : undefined; + const ruleObj: { id: string; name?: string } = { id }; + if (name) { + ruleObj.name = name; + } + expect(auditLoggerMock).toHaveBeenCalledWith( + expect.objectContaining({ + error: errorObj, + event: expect.objectContaining({ + outcome: errorMsg ? 'failure' : 'success', + action: RuleAuditAction.GET, + }), + kibana: expect.objectContaining({ + saved_object: expect.objectContaining(ruleObj), + }), + }) + ); + }; + testRules.successful.forEach(({ id, attributes: { name } }) => { + assertAuditLogCall(id, name); + }); + + testRules.erroredFetchingSo.forEach(({ id, error }) => { + assertAuditLogCall(id, undefined, error.message); + }); + + testRules.erroredAccess.forEach(({ id }) => { + assertAuditLogCall(id, undefined, 'Unauthorized'); + }); + }); + + it('should attempt to sanitize the rules', () => { + expect(transformToSanitizedRuleMock).toHaveBeenCalledTimes(testRules.successful.length); + testRules.successful.forEach((rule) => { + expect(transformToSanitizedRuleMock).toHaveBeenCalledWith(rulesClientContext, rule, {}); + }); + }); + + it('should return the sanitized rules', () => { + const expectedReturned = testRules.successful.map((rule) => ({ ...rule, sanitized: true })); + expect(results.rules).toEqual(expectedReturned); + }); + + it('should return any errors that occurred', () => { + expect(results.errors).toEqual([ + ...testRules.erroredFetchingSo, + ...testRules.erroredAccess.map(({ id }) => ({ id, error: new Error('Unauthorized') })), + ]); + }); +}); diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.ts new file mode 100644 index 0000000000000..7d2bdbb5261b4 --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.ts @@ -0,0 +1,117 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import Boom from '@hapi/boom'; +import pMap from 'p-map'; +import { chunk, groupBy, mapValues, omit } from 'lodash'; +import { ReadOperations, AlertingAuthorizationEntity } from '../../../../authorization'; +import { ruleAuditEvent, RuleAuditAction } from '../../../../rules_client/common/audit_events'; +import type { RulesClientContext } from '../../../../rules_client/types'; +import { RULE_SAVED_OBJECT_TYPE } from '../../../../saved_objects'; +import type { GetRulesParams } from './types'; +import { getRulesParamsSchema } from './schemas'; +import type { RuleParams } from '../../types'; +import { bulkGetRulesSo } from '../../../../data/rule'; +import { transformToSanitizedRule } from './utils'; +import type { GetRulesResponse } from './types/get_rules_response'; + +export async function getRules( + context: RulesClientContext, + params: GetRulesParams +): Promise> { + try { + getRulesParamsSchema.validate(params); + } catch (error) { + throw Boom.badRequest(`Error validating get rules params - ${error.message}`); + } + + const result: GetRulesResponse = { + rules: [], + errors: [], + }; + + const savedObjects: Awaited>['saved_objects'] = []; + + await pMap( + chunk(params.ids, 100), + async (ids) => { + // eslint-disable-next-line @typescript-eslint/naming-convention + const { saved_objects } = await bulkGetRulesSo({ + savedObjectsClient: context.unsecuredSavedObjectsClient, + ids, + }); + saved_objects.forEach((so) => { + if (so.error) { + result.errors.push({ id: so.id, error: so.error }); + return; + } + savedObjects.push(so); + }); + }, + { + concurrency: 10, + } + ); + + const alertTypes = mapValues( + groupBy(savedObjects, (rule) => `${rule.attributes.alertTypeId}<>${rule.attributes.consumer}`), + (groupedRules) => ({ + alertTypeId: groupedRules[0].attributes.alertTypeId, + consumer: groupedRules[0].attributes.consumer, + rules: groupedRules, + }) + ); + + const authorizedRuleSos: (typeof alertTypes)[0]['rules'] = []; + for (const { alertTypeId, consumer, rules } of Object.values(alertTypes)) { + try { + await context.authorization.ensureAuthorized({ + ruleTypeId: alertTypeId, + consumer, + operation: ReadOperations.Get, + entity: AlertingAuthorizationEntity.Rule, + }); + + authorizedRuleSos.push(...rules); + } catch (error) { + rules.forEach((rule) => { + result.errors.push({ + id: rule.id, + error, + }); + }); + } + } + + authorizedRuleSos.forEach((rule) => { + context.auditLogger?.log( + ruleAuditEvent({ + action: RuleAuditAction.GET, + savedObject: { type: RULE_SAVED_OBJECT_TYPE, id: rule.id, name: rule.attributes.name }, + }) + ); + }); + + result.errors.forEach(({ error, id }) => { + context.auditLogger?.log( + ruleAuditEvent({ + action: RuleAuditAction.GET, + savedObject: { type: RULE_SAVED_OBJECT_TYPE, id }, + error: new Error(error.message), + }) + ); + }); + + const paramsForTransform = omit(params, ['ids']); + const transformedRules = await pMap( + authorizedRuleSos, + (rule) => transformToSanitizedRule(context, rule, paramsForTransform), + { concurrency: 10 } + ); + result.rules.push(...transformedRules); + return result; +} diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/index.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/index.ts index cd47bf0db31ab..a90254160e763 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/index.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/index.ts @@ -6,4 +6,6 @@ */ export type { GetRuleParams } from './types'; +export type { GetRulesParams } from './types'; export { getRule } from './get_rule'; +export { getRules } from './get_rules'; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/get_rules_params_schema.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/get_rules_params_schema.ts new file mode 100644 index 0000000000000..dd4a8f902593a --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/get_rules_params_schema.ts @@ -0,0 +1,15 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import { schema } from '@kbn/config-schema'; + +export const getRulesParamsSchema = schema.object({ + ids: schema.arrayOf(schema.string()), + includeLegacyId: schema.maybe(schema.boolean()), + includeSnoozeData: schema.maybe(schema.boolean()), + excludeFromPublicApi: schema.maybe(schema.boolean()), +}); diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/index.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/index.ts index fed991d8a07b1..ad3a88772eebc 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/index.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/index.ts @@ -6,3 +6,4 @@ */ export * from './get_rule_params_schema'; +export * from './get_rules_params_schema'; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_params.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_params.ts new file mode 100644 index 0000000000000..8c0b355be0412 --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_params.ts @@ -0,0 +1,11 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import type { TypeOf } from '@kbn/config-schema'; +import type { getRulesParamsSchema } from '../schemas'; + +export type GetRulesParams = TypeOf; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_response.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_response.ts new file mode 100644 index 0000000000000..d18dcfa79551d --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_response.ts @@ -0,0 +1,14 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import type { SanitizedRule, SanitizedRuleWithLegacyId } from '../../../../../types'; +import type { RuleParams } from '../../../types'; + +export interface GetRulesResponse { + rules: Array | SanitizedRuleWithLegacyId>; + errors: Array<{ id: string; error: { message: string; statusCode?: number } }>; +} diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/index.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/index.ts index 553499a994ff6..686b6ea7e0c04 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/index.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/index.ts @@ -6,3 +6,4 @@ */ export * from './get_rule_params'; +export * from './get_rules_params'; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/utils.test.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/utils.test.ts new file mode 100644 index 0000000000000..3f126c33951d4 --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/utils.test.ts @@ -0,0 +1,182 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import { RecoveredActionGroup } from '../../../../../common'; +import { rulesClientContextMock } from '../../../../rules_client/rules_client.mock'; +import type { RulesClientContext } from '../../../../rules_client/types'; +import { RULE_SAVED_OBJECT_TYPE } from '../../../../saved_objects'; +import { transformToSanitizedRule } from './utils'; +import type { getRuleSo } from '../../../../data/rule'; +import { formatLegacyActions } from '../../../../rules_client/lib'; +import { AlertConsumers } from '@kbn/rule-data-utils'; + +type RuleSo = Awaited>; + +jest.mock('../../../../rules_client/lib', () => { + return { + formatLegacyActions: jest.fn(), + }; +}); + +const formatLegacyActionsMock = formatLegacyActions as jest.Mock; + +const getTestRule = (overrides?: { consumer?: string }) => { + const attributes = { + alertTypeId: '123', + schedule: { interval: '10s' }, + params: { + bar: true, + }, + executionStatus: { + status: 'unknown', + lastExecutionDate: new Date('2020-08-20T19:23:38Z'), + }, + createdAt: new Date().toISOString(), + updatedAt: new Date().toISOString(), + actions: [ + { + group: 'default', + actionRef: 'action_0', + params: { + foo: true, + }, + }, + ], + notifyWhen: 'onActiveAlert', + consumer: overrides?.consumer, + }; + const ruleSo = { + id: '1', + type: RULE_SAVED_OBJECT_TYPE, + attributes, + references: [ + { + name: 'action_0', + type: 'action', + id: '1', + }, + ], + } as unknown as RuleSo; + + const sanitized = { + actions: attributes.actions.map((action) => ({ + actionTypeId: undefined, + group: action.group, + id: ruleSo.references.find((ref) => ref.name === action.actionRef)?.id, + params: action.params, + uuid: undefined, + })), + alertTypeId: attributes.alertTypeId, + artifacts: { + dashboards: [], + investigation_guide: { blob: '' }, + }, + createdAt: new Date(attributes.createdAt), + executionStatus: { + lastExecutionDate: new Date(attributes.executionStatus.lastExecutionDate), + status: attributes.executionStatus.status, + }, + id: ruleSo.id, + notifyWhen: attributes.notifyWhen, + params: { + ...attributes.params, + parameterThatIsSavedObjectId: '9', + }, + schedule: attributes.schedule, + systemActions: [], + updatedAt: new Date(attributes.updatedAt), + consumer: ruleSo.attributes.consumer, + }; + + return { + so: ruleSo, + sanitized, + }; +}; + +let rulesClientContext: RulesClientContext; +let expectedSanitizedRule: ReturnType['sanitized']; +let result: Awaited>; + +const options = { includeLegacyId: true, includeSnoozeData: true, excludeFromPublicApi: true }; + +describe('transformToSanitizedRule', () => { + beforeEach(async () => { + jest.clearAllMocks(); + + rulesClientContext = rulesClientContextMock.create(); + const injectReferencesFn = jest.fn().mockReturnValue({ + bar: true, + parameterThatIsSavedObjectId: '9', + }); + const getRuleTypeRegistryMock = rulesClientContext.ruleTypeRegistry.get as jest.Mock; + getRuleTypeRegistryMock.mockImplementation(() => ({ + id: '123', + name: 'Test', + actionGroups: [{ id: 'default', name: 'Default' }], + recoveryActionGroup: RecoveredActionGroup, + defaultActionGroupId: 'default', + minimumLicenseRequired: 'basic', + isExportable: true, + async executor() { + return { state: {} }; + }, + category: 'test', + producer: 'alerts', + solution: 'stack', + useSavedObjectReferences: { + extractReferences: jest.fn(), + injectReferences: injectReferencesFn, + }, + validate: { + params: { validate: () => {} }, + }, + validLegacyConsumers: [], + })); + + const { so, sanitized } = getTestRule(); + expectedSanitizedRule = sanitized; + + result = await transformToSanitizedRule(rulesClientContext, so, options); + }); + + it('should transform the rule saved object to a SanitizedRule', () => { + expect(result).toEqual(expectedSanitizedRule); + }); + + it('should handle validation errors on the rule domain', () => { + expect(rulesClientContext.logger.warn).toHaveBeenCalledWith( + 'Error validating get rule domain object for id: 1, Error: [enabled]: expected value of type [boolean] but got [undefined]' + ); + }); + + it('should not format legacy actions for non SIEM rules', () => { + expect(formatLegacyActionsMock).not.toHaveBeenCalled(); + }); + + describe('when the rule is a SIEM rule', () => { + let sanitizedRule: ReturnType['sanitized']; + beforeEach(async () => { + const { so, sanitized } = getTestRule({ consumer: AlertConsumers.SIEM }); + sanitizedRule = sanitized; + expectedSanitizedRule = {} as typeof expectedSanitizedRule; + formatLegacyActionsMock.mockResolvedValueOnce([expectedSanitizedRule]); + result = await transformToSanitizedRule(rulesClientContext, so, options); + }); + it('should attempt to format legacy actions', () => { + expect(formatLegacyActionsMock).toHaveBeenCalledTimes(1); + expect(formatLegacyActionsMock).toHaveBeenCalledWith([sanitizedRule], { + savedObjectsClient: rulesClientContext.unsecuredSavedObjectsClient, + logger: rulesClientContext.logger, + }); + }); + + it('should return the migrated rule', () => { + expect(result).toBe(expectedSanitizedRule); + }); + }); +}); diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/utils.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/utils.ts new file mode 100644 index 0000000000000..12698e10495ee --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/utils.ts @@ -0,0 +1,72 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import { AlertConsumers } from '@kbn/rule-data-utils'; +import type { getRuleSo } from '../../../../data/rule'; +import { formatLegacyActions } from '../../../../rules_client/lib'; +import type { RulesClientContext } from '../../../../rules_client/types'; +import type { Rule as DeprecatedRule, SanitizedRule } from '../../../../types'; +import { ruleDomainSchema } from '../../schemas'; +import { transformRuleAttributesToRuleDomain, transformRuleDomainToRule } from '../../transforms'; +import type { RuleParams } from '../../types'; +import type { GetRuleParams } from './types'; + +type TransformToSanitizedRuleOptions = Omit; + +type RuleSo = Awaited>; + +export async function transformToSanitizedRule( + context: RulesClientContext, + ruleSo: RuleSo, + options: TransformToSanitizedRuleOptions +) { + const { + includeLegacyId = false, + includeSnoozeData = false, + excludeFromPublicApi = false, + } = options; + const ruleType = context.ruleTypeRegistry.get(ruleSo.attributes.alertTypeId); + + const ruleDomain = transformRuleAttributesToRuleDomain( + ruleSo.attributes, + { + id: ruleSo.id, + logger: context.logger, + ruleType, + references: ruleSo.references, + includeSnoozeData, + }, + context.isSystemAction + ); + + // Try to validate created rule, but don't throw. + try { + ruleDomainSchema.validate(ruleDomain); + } catch (e) { + context.logger.warn(`Error validating get rule domain object for id: ${ruleSo.id}, ${e}`); + } + + // Convert domain rule to rule (Remove certain properties) + const rule = transformRuleDomainToRule(ruleDomain, { + isPublic: excludeFromPublicApi, + includeLegacyId, + }); + + // format legacy actions for SIEM rules + if (ruleSo.attributes.consumer === AlertConsumers.SIEM) { + const [migratedRule] = await formatLegacyActions([rule as DeprecatedRule], { + savedObjectsClient: context.unsecuredSavedObjectsClient, + logger: context.logger, + }); + + return migratedRule; + } + + // TODO (http-versioning): Remove this cast, this enables us to move forward + // without fixing all of other solution types + return rule as SanitizedRule; +} diff --git a/x-pack/platform/plugins/shared/alerting/server/data/rule/index.ts b/x-pack/platform/plugins/shared/alerting/server/data/rule/index.ts index fcc983d9c1b6f..1a8239bc1492b 100644 --- a/x-pack/platform/plugins/shared/alerting/server/data/rule/index.ts +++ b/x-pack/platform/plugins/shared/alerting/server/data/rule/index.ts @@ -25,3 +25,5 @@ export { getDecryptedRuleSo } from './methods/get_decrypted_rule_so'; export type { GetDecryptedRuleSoParams } from './methods/get_decrypted_rule_so'; export { bulkDisableRulesSo } from './methods/bulk_disable_rules_so'; export type { BulkDisableRulesSoParams } from './methods/bulk_disable_rules_so'; +export { bulkGetRulesSo } from './methods/bulk_get_rules_so'; +export type { BulkGetRulesSoParams } from './methods/bulk_get_rules_so'; diff --git a/x-pack/platform/plugins/shared/alerting/server/data/rule/methods/bulk_get_rules_so.ts b/x-pack/platform/plugins/shared/alerting/server/data/rule/methods/bulk_get_rules_so.ts new file mode 100644 index 0000000000000..539414b6e49e6 --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/data/rule/methods/bulk_get_rules_so.ts @@ -0,0 +1,31 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import type { SavedObjectsClientContract } from '@kbn/core/server'; +import type { + SavedObjectsBulkResponse, + SavedObjectsGetOptions, +} from '@kbn/core-saved-objects-api-server'; +import type { RawRule } from '../../../types'; +import { RULE_SAVED_OBJECT_TYPE } from '../../../saved_objects'; + +export interface BulkGetRulesSoParams { + savedObjectsClient: SavedObjectsClientContract; + ids: string[]; + savedObjectsGetOptions?: SavedObjectsGetOptions; +} + +export const bulkGetRulesSo = ( + params: BulkGetRulesSoParams +): Promise> => { + const { savedObjectsClient, ids, savedObjectsGetOptions } = params; + + return savedObjectsClient.bulkGet( + ids.map((id) => ({ type: RULE_SAVED_OBJECT_TYPE, id })), + savedObjectsGetOptions + ); +}; diff --git a/x-pack/platform/plugins/shared/alerting/server/rules_client.mock.ts b/x-pack/platform/plugins/shared/alerting/server/rules_client.mock.ts index 756a1bcbaf87d..5c6ea245c2e18 100644 --- a/x-pack/platform/plugins/shared/alerting/server/rules_client.mock.ts +++ b/x-pack/platform/plugins/shared/alerting/server/rules_client.mock.ts @@ -47,6 +47,7 @@ const createRulesClientMock = () => { findBackfill: jest.fn(), deleteBackfill: jest.fn(), getSpaceId: jest.fn(), + bulkGet: jest.fn(), bulkEdit: jest.fn(), bulkDeleteRules: jest.fn(), bulkEnableRules: jest.fn(), diff --git a/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.mock.ts b/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.mock.ts index 0d847e43205c2..55d0eec311c5b 100644 --- a/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.mock.ts +++ b/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.mock.ts @@ -10,7 +10,6 @@ import { loggingSystemMock } from '@kbn/core-logging-server-mocks'; import { uiSettingsServiceMock } from '@kbn/core-ui-settings-server-mocks'; import type { AlertingAuthorization } from '../authorization'; import { ConnectorAdapterRegistry } from '../connector_adapters/connector_adapter_registry'; -import type { ConstructorOptions } from './rules_client'; import { actionsAuthorizationMock } from '@kbn/actions-plugin/server/mocks'; import { savedObjectsClientMock, @@ -22,6 +21,8 @@ import { taskManagerMock } from '@kbn/task-manager-plugin/server/mocks'; import { alertingAuthorizationMock } from '../authorization/alerting_authorization.mock'; import { backfillClientMock } from '../backfill_client/backfill_client.mock'; import { ruleTypeRegistryMock } from '../rule_type_registry.mock'; +import { fieldsToExcludeFromPublicApi } from './rules_client'; +import type { RulesClientContext } from './types'; const create = () => { const kibanaVersion = 'v8.17.0'; @@ -35,7 +36,7 @@ const create = () => { const internalSavedObjectsRepository = savedObjectsRepositoryMock.create(); const backfillClient = backfillClientMock.create(); - const rulesClientParams: jest.Mocked = { + const rulesClientParams: jest.Mocked = { taskManager, ruleTypeRegistry, unsecuredSavedObjectsClient, @@ -62,6 +63,8 @@ const create = () => { isSystemAction: jest.fn(), connectorAdapterRegistry: new ConnectorAdapterRegistry(), uiSettings: uiSettingsServiceMock.createStartContract(), + minimumScheduleIntervalInMs: 0, + fieldsToExcludeFromPublicApi, }; return rulesClientParams; diff --git a/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.ts b/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.ts index 71368f6bf7abb..e19734123fb08 100644 --- a/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.ts +++ b/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.ts @@ -22,8 +22,8 @@ import type { SnoozeRuleOptions } from '../application/rule/methods/snooze'; import { snoozeRule } from '../application/rule/methods/snooze'; import type { UnsnoozeParams } from '../application/rule/methods/unsnooze'; import { unsnoozeRule } from '../application/rule/methods/unsnooze'; -import type { GetRuleParams } from '../application/rule/methods/get'; -import { getRule } from '../application/rule/methods/get'; +import type { GetRuleParams, GetRulesParams } from '../application/rule/methods/get'; +import { getRule, getRules } from '../application/rule/methods/get'; import type { ResolveParams } from '../application/rule/methods/resolve'; import { resolveRule } from '../application/rule/methods/resolve'; import type { GetAlertStateParams } from './methods/get_alert_state'; @@ -170,6 +170,8 @@ export class RulesClient { public getActionErrorLogWithAuth = (params: GetActionErrorLogByIdParams) => getActionErrorLogWithAuth(this.context, params); + public bulkGet = (params: GetRulesParams) => + getRules(this.context, params); public bulkDeleteRules = (options: BulkDeleteRulesRequestBody) => bulkDeleteRules(this.context, options); public bulkEdit = (options: BulkEditOptions) => diff --git a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts index c20ee9cc2132d..cf2d8b214acdf 100644 --- a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts +++ b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts @@ -8,41 +8,41 @@ import type { RulesClient } from '@kbn/alerting-plugin/server'; import { BadRequestError } from '@kbn/securitysolution-es-utils'; import { gapStatus } from '@kbn/alerting-plugin/common'; -import { MAX_RULES_TO_UPDATE_IN_PARALLEL } from '../../../../../../../common/constants'; import type { PromisePoolOutcome } from '../../../../../../utils/promise_pool'; -import { initPromisePool } from '../../../../../../utils/promise_pool'; import type { RuleAlertType } from '../../../../rule_schema'; -import { readRules } from '../../../logic/detection_rules_client/read_rules'; import { findRules } from '../../../logic/search/find_rules'; export const fetchRulesByQueryOrIds = async ({ query, ids, rulesClient, - abortSignal, maxRules, gapRange, }: { query: string | undefined; ids: string[] | undefined; rulesClient: RulesClient; - abortSignal: AbortSignal; maxRules: number; gapRange?: { start: string; end: string }; }): Promise> => { if (ids) { - return initPromisePool({ - concurrency: MAX_RULES_TO_UPDATE_IN_PARALLEL, - items: ids, - executor: async (id: string) => { - const rule = await readRules({ id, rulesClient, ruleId: undefined }); - if (rule == null) { - throw Error('Rule not found'); + const { rules, errors } = await rulesClient.bulkGet({ ids }); + return { + results: rules.map((rule) => ({ + item: rule.id, + result: rule, + })), + errors: errors.map(({ id, error }) => { + let message = 'Error resolving the rule'; + if (error.statusCode === 404) { + message = 'Rule not found'; } - return rule; - }, - abortSignal, - }); + return { + item: id, + error: new Error(message), + }; + }), + }; } let ruleIdsWithGaps: string[] | undefined; diff --git a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.test.ts b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.test.ts index 2795956fc791b..64b1b56f0f4c4 100644 --- a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.test.ts +++ b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.test.ts @@ -21,23 +21,23 @@ import { getPerformBulkActionEditSchemaMock, getBulkDisableRuleActionSchemaMock, } from '../../../../../../../common/api/detection_engine/rule_management/mocks'; -import { readRules } from '../../../logic/detection_rules_client/read_rules'; import { BulkActionsDryRunErrCodeEnum } from '../../../../../../../common/api/detection_engine'; jest.mock('../../../../../machine_learning/authz'); -jest.mock('../../../logic/detection_rules_client/read_rules', () => ({ readRules: jest.fn() })); + +let bulkGetRulesMock: jest.Mock; describe('Perform bulk action route', () => { - const readRulesMock = readRules as jest.Mock; let server: ReturnType; let { clients, context } = requestContextMock.createTools(); let ml: ReturnType; const mockRule = getFindResultWithSingleHit().data[0]; - beforeEach(() => { + beforeEach(async () => { server = serverMock.create(); ({ clients, context } = requestContextMock.createTools()); ml = mlServicesMock.createSetupContract(); + bulkGetRulesMock = (await context.alerting.getRulesClient()).bulkGet as jest.Mock; clients.rulesClient.find.mockResolvedValue(getFindResultWithSingleHit()); clients.rulesClient.bulkDisableRules.mockResolvedValue({ @@ -326,9 +326,10 @@ describe('Perform bulk action route', () => { }); it('returns partial failure error if one if rules from ids params can`t be fetched', async () => { - readRulesMock - .mockImplementationOnce(() => Promise.resolve(mockRule)) - .mockImplementationOnce(() => Promise.resolve(null)); + bulkGetRulesMock.mockImplementation(() => ({ + rules: [mockRule], + errors: [{ id: 'failed-mock-id', error: { statusCode: 404 } }], + })); const request = requestMock.create({ method: 'patch', diff --git a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.ts b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.ts index 6a685c0f7874a..446f1764bc7bc 100644 --- a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.ts +++ b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.ts @@ -197,7 +197,6 @@ export const performBulkActionRoute = ( rulesClient, query, ids: body.ids, - abortSignal: abortController.signal, maxRules: body.action === BulkActionTypeEnum.edit ? MAX_RULES_TO_BULK_EDIT From 14372bc51c6884e67bf4d50d6e992801eeaa7b69 Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Mon, 2 Jun 2025 10:24:49 +0200 Subject: [PATCH 02/14] Optimize the update gaps routine - Pre process the scheduled items before going through the for each gap - Only process scheduled items that overlap with the time range of the gap --- .../server/backfill_client/backfill_client.ts | 55 +++++---- .../lib/rule_gaps/gap/interval_utils.ts | 26 ++-- .../rule_gaps/update/calculate_gaps_state.ts | 4 +- .../update/update_gap_from_schedule.test.ts | 44 +++---- .../update/update_gap_from_schedule.ts | 17 +-- .../lib/rule_gaps/update/update_gaps.test.ts | 26 ++-- .../lib/rule_gaps/update/update_gaps.ts | 62 ++++++---- .../server/lib/rule_gaps/update/utils.test.ts | 112 +++++++++++++++++ .../server/lib/rule_gaps/update/utils.ts | 116 ++++++++++++++++++ 9 files changed, 359 insertions(+), 103 deletions(-) create mode 100644 x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.test.ts create mode 100644 x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.ts diff --git a/x-pack/platform/plugins/shared/alerting/server/backfill_client/backfill_client.ts b/x-pack/platform/plugins/shared/alerting/server/backfill_client/backfill_client.ts index 7e79be58dc84f..cd9c2423e8501 100644 --- a/x-pack/platform/plugins/shared/alerting/server/backfill_client/backfill_client.ts +++ b/x-pack/platform/plugins/shared/alerting/server/backfill_client/backfill_client.ts @@ -26,6 +26,7 @@ import { TaskPriority } from '@kbn/task-manager-plugin/server'; import type { IEventLogger, IEventLogClient } from '@kbn/event-log-plugin/server'; import { isNumber } from 'lodash'; import type { ActionsClient } from '@kbn/actions-plugin/server'; +import { withSpan } from '@kbn/apm-utils'; import type { ScheduleBackfillError, ScheduleBackfillParams, @@ -278,34 +279,36 @@ export class BackfillClient { } }); - try { - // Process backfills in chunks of 10 to manage resource usage - for (let i = 0; i < backfillSOs.length; i += 10) { - const chunk = backfillSOs.slice(i, i + 10); - await Promise.all( - chunk.map((backfill) => - updateGaps({ - backfillSchedule: backfill.schedule, - ruleId: backfill.rule.id, - start: new Date(backfill.start), - end: backfill?.end ? new Date(backfill.end) : new Date(), - eventLogger, - eventLogClient, - savedObjectsRepository: internalSavedObjectsRepository, - logger: this.logger, - backfillClient: this, - actionsClient, - }) - ) + await withSpan({ name: 'backfillClient.bulkQueue.updateGaps', type: 'rule' }, async () => { + try { + // Process backfills in chunks of 10 to manage resource usage + for (let i = 0; i < backfillSOs.length; i += 10) { + const chunk = backfillSOs.slice(i, i + 10); + await Promise.all( + chunk.map((backfill) => + updateGaps({ + backfillSchedule: backfill.schedule, + ruleId: backfill.rule.id, + start: new Date(backfill.start), + end: backfill?.end ? new Date(backfill.end) : new Date(), + eventLogger, + eventLogClient, + savedObjectsRepository: internalSavedObjectsRepository, + logger: this.logger, + backfillClient: this, + actionsClient, + }) + ) + ); + } + } catch { + this.logger.warn( + `Error updating gaps for backfill jobs: ${backfillSOs + .map((backfill) => backfill.id) + .join(', ')}` ); } - } catch { - this.logger.warn( - `Error updating gaps for backfill jobs: ${backfillSOs - .map((backfill) => backfill.id) - .join(', ')}` - ); - } + }); if (adHocTasksToSchedule.length > 0) { const taskManager = await this.taskManagerStartPromise; diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.ts index 3adb694b9ea88..5f7af3e4dc0d6 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.ts @@ -209,17 +209,27 @@ export const denormalizeInterval = (interval: Interval): StringInterval => { * If there's no overlap, returns null. */ export const clipInterval = (interval: Interval, boundary: Interval): Interval | null => { - const gte = interval.gte.getTime(); - const lte = interval.lte.getTime(); - const boundaryGte = boundary.gte.getTime(); - const boundaryLte = boundary.lte.getTime(); + const clipped = clipDateIntervals(interval.gte, interval.lte, boundary.gte, boundary.lte); - const clippedGte = Math.max(gte, boundaryGte); - const clippedLte = Math.min(lte, boundaryLte); + if (clipped === null) { + return null; + } + + return { gte: clipped.start, lte: clipped.end }; +}; + +export const clipDateIntervals = ( + start: Date, + end: Date, + boundaryStart: Date, + boundaryEnd: Date +) => { + const clippedStart = Math.max(start.getTime(), boundaryStart.getTime()); + const clippedEnd = Math.min(end.getTime(), boundaryEnd.getTime()); - if (clippedGte >= clippedLte) { + if (clippedStart >= clippedEnd) { return null; } - return { gte: new Date(clippedGte), lte: new Date(clippedLte) }; + return { start: new Date(clippedStart), end: new Date(clippedEnd) }; }; diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.ts index a863ac873893e..64960ee8539b8 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.ts @@ -10,6 +10,7 @@ import type { ActionsClient } from '@kbn/actions-plugin/server'; import type { Gap } from '../gap'; import { updateGapFromSchedule } from './update_gap_from_schedule'; import type { BackfillClient } from '../../../backfill_client/backfill_client'; +import { toScheduledItem } from './utils'; /** * Find all overlapping backfill tasks and update the gap status accordingly @@ -40,9 +41,10 @@ export const calculateGapStateFromAllBackfills = async ({ if ('error' in backfill) { continue; } + const scheduledItems = backfill?.schedule.map(toScheduledItem) ?? []; gap = updateGapFromSchedule({ gap, - backfillSchedule: backfill?.schedule ?? [], + scheduledItems, }); } diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gap_from_schedule.test.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gap_from_schedule.test.ts index 068541c54a0fe..9b22f47170130 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gap_from_schedule.test.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gap_from_schedule.test.ts @@ -23,7 +23,7 @@ describe('updateGapFromSchedule', () => { const gap = createTestGap(); const updatedGap = updateGapFromSchedule({ gap, - backfillSchedule: [], + scheduledItems: [], }); expect(updatedGap.filledIntervals).toHaveLength(0); @@ -34,10 +34,10 @@ describe('updateGapFromSchedule', () => { const gap = createTestGap(); const updatedGap = updateGapFromSchedule({ gap, - backfillSchedule: [ + scheduledItems: [ { - runAt: '2024-01-01T00:15:00.000Z', - interval: '15m', + from: new Date('2024-01-01T00:00:00.000Z'), + to: new Date('2024-01-01T00:15:00.000Z'), status: adHocRunStatus.COMPLETE, }, ], @@ -54,10 +54,10 @@ describe('updateGapFromSchedule', () => { const gap = createTestGap(); const updatedGap = updateGapFromSchedule({ gap, - backfillSchedule: [ + scheduledItems: [ { - runAt: '2024-01-01T00:15:00.000Z', - interval: '15m', + from: new Date('2024-01-01T00:00:00.000Z'), + to: new Date('2024-01-01T00:15:00.000Z'), status: adHocRunStatus.RUNNING, }, ], @@ -76,15 +76,15 @@ describe('updateGapFromSchedule', () => { const gap = createTestGap(); const updatedGap = updateGapFromSchedule({ gap, - backfillSchedule: [ + scheduledItems: [ { - runAt: '2024-01-01T00:15:00.000Z', - interval: '15m', + from: new Date('2024-01-01T00:00:00.000Z'), + to: new Date('2024-01-01T00:15:00.000Z'), status: adHocRunStatus.COMPLETE, }, { - runAt: '2024-01-01T00:20:00.000Z', - interval: '15m', + from: new Date('2024-01-01T00:05:00.000Z'), + to: new Date('2024-01-01T00:20:00.000Z'), status: adHocRunStatus.COMPLETE, }, ], @@ -101,20 +101,20 @@ describe('updateGapFromSchedule', () => { const gap = createTestGap(); const updatedGap = updateGapFromSchedule({ gap, - backfillSchedule: [ + scheduledItems: [ { - runAt: '2024-01-01T00:15:00.000Z', - interval: '15m', + from: new Date('2024-01-01T00:00:00.000Z'), + to: new Date('2024-01-01T00:15:00.000Z'), status: adHocRunStatus.COMPLETE, }, { - runAt: '2024-01-01T00:30:00.000Z', - interval: '15m', + from: new Date('2024-01-01T00:15:00.000Z'), + to: new Date('2024-01-01T00:30:00.000Z'), status: adHocRunStatus.RUNNING, }, { - runAt: '2024-01-01T00:45:00.000Z', - interval: '15m', + from: new Date('2024-01-01T00:30:00.000Z'), + to: new Date('2024-01-01T00:45:00.000Z'), status: adHocRunStatus.PENDING, }, ], @@ -138,10 +138,10 @@ describe('updateGapFromSchedule', () => { const gap = createTestGap(); const updatedGap = updateGapFromSchedule({ gap, - backfillSchedule: [ + scheduledItems: [ { - runAt: '2024-01-01T02:00:00.000Z', // Outside gap range - interval: '15m', + from: new Date('2024-01-01T01:45:00.000Z'), + to: new Date('2024-01-01T02:00:00.000Z'), // Outside gap range status: adHocRunStatus.COMPLETE, }, ], diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gap_from_schedule.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gap_from_schedule.ts index e4f48a7edd424..ab0ef7a0c5fbb 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gap_from_schedule.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gap_from_schedule.ts @@ -7,24 +7,19 @@ import type { Gap } from '../gap'; import { adHocRunStatus } from '../../../../common/constants'; -import { parseDuration } from '../../../../common'; -import type { BackfillSchedule } from '../../../application/backfill/result/types'; +import type { ScheduledItem } from './utils'; export const updateGapFromSchedule = ({ gap, - backfillSchedule, + scheduledItems, }: { gap: Gap; - backfillSchedule: BackfillSchedule[]; + scheduledItems: ScheduledItem[]; }) => { - for (const scheduleItem of backfillSchedule) { - const runAt = new Date(scheduleItem.runAt).getTime(); - const intervalDuration = parseDuration(scheduleItem.interval); - const from = runAt - intervalDuration; - const to = runAt; + for (const scheduleItem of scheduledItems) { const scheduleInterval = { - gte: new Date(from), - lte: new Date(to), + gte: scheduleItem.from, + lte: scheduleItem.to, }; if ( scheduleItem.status === adHocRunStatus.PENDING || diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.test.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.test.ts index 05981aa2a0902..b17d89a1cccde 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.test.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.test.ts @@ -86,7 +86,7 @@ describe('updateGaps', () => { ruleId: 'test-rule-id', start: '2024-01-01T00:00:00.000Z', end: '2024-01-01T01:00:00.000Z', - perPage: 500, + perPage: 1000, statuses: ['partially_filled', 'unfilled'], sortField: '@timestamp', sortOrder: 'asc', @@ -298,14 +298,6 @@ describe('updateGaps', () => { searchAfter: undefined, }); - const backfillSchedule = [ - { - runAt: '2024-01-01T00:30:00.000Z', - interval: '30m', - status: adHocRunStatus.COMPLETE, - }, - ]; - await updateGaps({ ruleId: 'test-rule-id', start: new Date('2024-01-01T00:00:00.000Z'), @@ -314,14 +306,26 @@ describe('updateGaps', () => { eventLogClient: mockEventLogClient, logger: mockLogger, savedObjectsRepository: mockSavedObjectsRepository, - backfillSchedule, + backfillSchedule: [ + { + runAt: '2024-01-01T00:30:00.000Z', + interval: '30m', + status: adHocRunStatus.COMPLETE, + }, + ], backfillClient: mockBackfillClient, actionsClient: mockActionsClient, }); expect(updateGapFromSchedule).toHaveBeenCalledWith({ gap: testGap, - backfillSchedule, + scheduledItems: [ + { + from: new Date('2024-01-01T00:00:00.000Z'), + to: new Date('2024-01-01T00:30:00.000Z'), + status: adHocRunStatus.COMPLETE, + }, + ], }); expect(calculateGapStateFromAllBackfills).not.toHaveBeenCalled(); }); diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts index 5fdf9d5198d4e..24069cad32130 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts @@ -9,6 +9,7 @@ import type { Logger, ISavedObjectsRepository } from '@kbn/core/server'; import type { IEventLogClient, IEventLogger } from '@kbn/event-log-plugin/server'; import type { SortResults } from '@elastic/elasticsearch/lib/api/types'; import type { ActionsClient } from '@kbn/actions-plugin/server'; +import { withSpan } from '@kbn/apm-utils'; import type { BackfillClient } from '../../../backfill_client/backfill_client'; import { AlertingEventLogger } from '../../alerting_event_logger/alerting_event_logger'; import { findGapsSearchAfter } from '../find_gaps'; @@ -19,6 +20,8 @@ import { adHocRunStatus } from '../../../../common/constants'; import { calculateGapStateFromAllBackfills } from './calculate_gaps_state'; import { updateGapFromSchedule } from './update_gap_from_schedule'; import { mgetGaps } from '../mget_gaps'; +import type { ScheduledItem } from './utils'; +import { findOverlappingIntervals, toScheduledItem } from './utils'; interface UpdateGapsParams { ruleId: string; @@ -36,20 +39,20 @@ interface UpdateGapsParams { const CONFLICT_STATUS_CODE = 409; const MAX_RETRIES = 3; -const PAGE_SIZE = 500; +const PAGE_SIZE = 1000; const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms)); export const prepareGapForUpdate = async ( gap: Gap, { - backfillSchedule, + scheduledItems, savedObjectsRepository, shouldRefetchAllBackfills, backfillClient, actionsClient, ruleId, }: { - backfillSchedule?: BackfillSchedule[]; + scheduledItems: ScheduledItem[]; savedObjectsRepository: ISavedObjectsRepository; shouldRefetchAllBackfills?: boolean; backfillClient: BackfillClient; @@ -57,19 +60,24 @@ export const prepareGapForUpdate = async ( ruleId: string; } ) => { - const hasFailedBackfillTask = backfillSchedule?.some( + const hasFailedBackfillTask = scheduledItems?.some( (scheduleItem) => scheduleItem.status === adHocRunStatus.ERROR || scheduleItem.status === adHocRunStatus.TIMEOUT ); - if (backfillSchedule && !hasFailedBackfillTask) { - updateGapFromSchedule({ - gap, - backfillSchedule, - }); + if (scheduledItems.length > 0 && !hasFailedBackfillTask) { + await withSpan( + { name: 'updateGaps.prepareGapForUpdate.updateGapFromSchedule', type: 'rules' }, + async () => { + updateGapFromSchedule({ + gap, + scheduledItems, + }); + } + ); } - if (hasFailedBackfillTask || !backfillSchedule || shouldRefetchAllBackfills) { + if (hasFailedBackfillTask || !scheduledItems || shouldRefetchAllBackfills) { await calculateGapStateFromAllBackfills({ gap, savedObjectsRepository, @@ -110,19 +118,22 @@ const updateGapBatch = async ( ): Promise => { try { // Prepare all gaps for update - const updatedGaps = []; - for (const gap of gaps) { - // we do async request only if there errors in backfill or no backfill schedule - const updatedGap = await prepareGapForUpdate(gap, { - backfillSchedule, - savedObjectsRepository, - shouldRefetchAllBackfills, - backfillClient, - actionsClient, - ruleId, - }); - updatedGaps.push(updatedGap); - } + const updatedGaps: Gap[] = []; + const scheduledItems = backfillSchedule?.map(toScheduledItem) ?? []; + await withSpan({ name: 'updateGaps.prepareGapsForUpdate', type: 'rule' }, async () => { + for (const { gap, scheduled } of findOverlappingIntervals(gaps, scheduledItems)) { + // we do async request only if there errors in backfill or no backfill schedule + const updatedGap = await prepareGapForUpdate(gap, { + scheduledItems: scheduled, + savedObjectsRepository, + shouldRefetchAllBackfills, + backfillClient, + actionsClient, + ruleId, + }); + updatedGaps.push(updatedGap); + } + }); // Convert gaps to the format expected by updateDocuments const gapsToUpdate = updatedGaps @@ -140,7 +151,10 @@ const updateGapBatch = async ( } // Attempt bulk update - const bulkResponse = await alertingEventLogger.updateGaps(gapsToUpdate); + const bulkResponse = await withSpan( + { name: 'updateGaps.alertingEventLogger.updateGaps', type: 'rule' }, + () => alertingEventLogger.updateGaps(gapsToUpdate) + ); if (bulkResponse.errors) { if (retryCount >= MAX_RETRIES) { diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.test.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.test.ts new file mode 100644 index 0000000000000..1fbfb8baf94db --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.test.ts @@ -0,0 +1,112 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import type { Gap } from '../gap'; +import type { ScheduledItem } from './utils'; +import { findOverlappingIntervals } from './utils'; + +const getGap = (start: string, end: string) => + ({ range: { gte: new Date(start), lte: new Date(end) } } as Gap); +const getScheduledItem = (start: string, end: string) => + ({ from: new Date(start), to: new Date(end), status: 'pending' } as ScheduledItem); + +describe('findOverlappingIntervals', () => { + // 1 hour worth of scheduled items + const scheduledItems = [ + getScheduledItem('2025-01-02T00:00:00Z', '2025-01-02T00:15:00Z'), + getScheduledItem('2025-01-02T00:15:00Z', '2025-01-02T00:30:00Z'), + getScheduledItem('2025-01-02T00:40:00Z', '2025-01-02T00:45:00Z'), + getScheduledItem('2025-01-02T00:45:00Z', '2025-01-02T01:00:00Z'), + ]; + + const cases = [ + { + description: 'when the gap is before of the scheduled items range', + gap: getGap('2025-01-01T23:00:00Z', '2025-01-01T23:40:00Z'), + expectedOverlapping: [], + }, + { + description: 'when the gap ends right at the scheduling start date', + gap: getGap('2025-01-01T23:00:00Z', '2025-01-02T00:00:00Z'), + expectedOverlapping: [], + }, + { + description: 'when the gap starts outside the scheduling range and ends inside', + gap: getGap('2025-01-01T23:50:00Z', '2025-01-02T00:10:00Z'), + expectedOverlapping: [getScheduledItem('2025-01-02T00:00:00Z', '2025-01-02T00:10:00Z')], + }, + { + description: + 'when the gap starts outside the scheduling range and ends inside at the start of a scheduled item', + gap: getGap('2025-01-01T23:50:00Z', '2025-01-02T00:40:00Z'), + expectedOverlapping: [ + getScheduledItem('2025-01-02T00:00:00Z', '2025-01-02T00:15:00Z'), + getScheduledItem('2025-01-02T00:15:00Z', '2025-01-02T00:30:00Z'), + ], + }, + { + description: + 'when the gap starts outside the scheduling range and ends inside at the end of a scheduled item', + gap: getGap('2025-01-01T23:50:00Z', '2025-01-02T00:45:00Z'), + expectedOverlapping: [ + getScheduledItem('2025-01-02T00:00:00Z', '2025-01-02T00:15:00Z'), + getScheduledItem('2025-01-02T00:15:00Z', '2025-01-02T00:30:00Z'), + getScheduledItem('2025-01-02T00:40:00Z', '2025-01-02T00:45:00Z'), + ], + }, + { + description: 'when the gap starts right at the start of the scheduling range and ends inside', + gap: getGap('2025-01-02T00:00:00Z', '2025-01-02T00:10:00Z'), + expectedOverlapping: [getScheduledItem('2025-01-02T00:00:00Z', '2025-01-02T00:10:00Z')], + }, + { + description: 'when the gap covers the entire sheduling range', + gap: getGap('2025-01-02T00:00:00Z', '2025-01-02T01:00:00Z'), + expectedOverlapping: scheduledItems, + }, + { + description: 'when the gap starts inside the scheduling range and ends inside', + gap: getGap('2025-01-02T00:10:00Z', '2025-01-02T00:41:00Z'), + expectedOverlapping: [ + getScheduledItem('2025-01-02T00:10:00Z', '2025-01-02T00:15:00Z'), + getScheduledItem('2025-01-02T00:15:00Z', '2025-01-02T00:30:00Z'), + getScheduledItem('2025-01-02T00:40:00Z', '2025-01-02T00:41:00Z'), + ], + }, + { + description: 'when the gap starts inside the scheduling range and ends outside of it', + gap: getGap('2025-01-02T00:41:00Z', '2025-01-02T01:10:00Z'), + expectedOverlapping: [ + getScheduledItem('2025-01-02T00:41:00Z', '2025-01-02T00:45:00Z'), + getScheduledItem('2025-01-02T00:45:00Z', '2025-01-02T01:00:00Z'), + ], + }, + { + description: 'when the gap starts at the end of the scheduling range', + gap: getGap('2025-01-02T01:00:00Z', '2025-01-02T01:30:00Z'), + expectedOverlapping: [], + }, + { + description: 'when the gap starts after the scheduling range', + gap: getGap('2025-01-02T01:10:00Z', '2025-01-02T01:30:00Z'), + expectedOverlapping: [], + }, + ]; + + const results = findOverlappingIntervals( + cases.map(({ gap }) => gap), + scheduledItems + ); + + cases.forEach(({ description, gap, expectedOverlapping }, idx) => { + describe(description, () => { + it('should return the right scheduled items', () => { + expect(results[idx]).toEqual({ gap, scheduled: expectedOverlapping }); + }); + }); + }); +}); diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.ts new file mode 100644 index 0000000000000..49bff67ef9900 --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.ts @@ -0,0 +1,116 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import type { BackfillSchedule } from '../../../application/backfill/result/types'; +import { parseDuration } from '../../../../common'; +import { clipDateIntervals } from '../gap/interval_utils'; +import type { Gap } from '../gap'; + +export interface ScheduledItem { + from: Date; + to: Date; + status: BackfillSchedule['status']; +} + +export const toScheduledItem = (backfillSchedule: BackfillSchedule): ScheduledItem => { + const runAt = new Date(backfillSchedule.runAt).getTime(); + const intervalDuration = parseDuration(backfillSchedule.interval); + const from = runAt - intervalDuration; + const to = runAt; + return { + from: new Date(from), + to: new Date(to), + status: backfillSchedule.status, + }; +}; + +const findEarliestOverlapping = ( + startMs: number, + endMs: number, + scheduledItems: ScheduledItem[] +) => { + let startIdx = 0; + let endIdx = scheduledItems.length - 1; + + let earliestOverlapping = scheduledItems.length; + + while (startIdx <= endIdx) { + const midIdx = Math.floor((endIdx - startIdx) / 2) + startIdx; + const scheduledItem = scheduledItems[midIdx]; + + if (endMs <= scheduledItem.from.getTime()) { + endIdx = midIdx - 1; + continue; + } + + if (startMs >= scheduledItem.to.getTime()) { + startIdx = midIdx + 1; + continue; + } + + // There is an overlap at this point + earliestOverlapping = Math.min(earliestOverlapping, midIdx); + // go left to see if there is an erlier interval + endIdx = midIdx - 1; + } + + return earliestOverlapping < scheduledItems.length ? earliestOverlapping : null; +}; + +const clipScheduled = (startMs: number, endMs: number, scheduledItem: ScheduledItem) => { + const clipped = clipDateIntervals( + scheduledItem.from, + scheduledItem.to, + new Date(startMs), + new Date(endMs) + ); + if (clipped === null) { + throw new Error('Clipped interval in an scheduled item cannot be null'); + } + + return { + from: clipped.start, + to: clipped.end, + status: scheduledItem.status, + }; +}; + +const findOverlapping = (startMs: number, endMs: number, scheduledItems: ScheduledItem[]) => { + let earliestIdx = findEarliestOverlapping(startMs, endMs, scheduledItems); + const overlapping: ScheduledItem[] = []; + if (earliestIdx === null) { + return overlapping; + } + + while (earliestIdx < scheduledItems.length) { + const scheduled = scheduledItems[earliestIdx]; + if (scheduled.from.getTime() >= endMs) { + break; + } + + overlapping.push(scheduled); + earliestIdx++; + } + + overlapping[0] = clipScheduled(startMs, endMs, overlapping[0]); + overlapping[overlapping.length - 1] = clipScheduled( + startMs, + endMs, + overlapping[overlapping.length - 1] + ); + + return overlapping; +}; + +export const findOverlappingIntervals = (gaps: Gap[], scheduledItems: ScheduledItem[]) => { + return gaps.map((gap) => { + return { + gap, + scheduled: findOverlapping(gap.range.gte.getTime(), gap.range.lte.getTime(), scheduledItems), + }; + }); +}; From 21069c188d657c054130774b812f756a9a3862ab Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Mon, 9 Jun 2025 11:22:13 +0200 Subject: [PATCH 03/14] Code review improvements - move get rules to its own method folder in the rules client - rename bulkGet to bulkGetRules - move the transformRuleSoToSanitizedRule function to the transforms folder --- .../bulk_get_rules.test.ts} | 28 +-- .../bulk_get_rules.ts} | 20 +- .../rule/methods/bulk_get/index.ts | 9 + .../schemas/bulk_get_rules_params_schema.ts} | 4 +- .../rule/methods/bulk_get/schemas/index.ts | 8 + .../types/bulk_get_rules_params.ts} | 4 +- .../types/bulk_get_rules_response.ts} | 2 +- .../rule/methods/bulk_get/types/index.ts | 9 + .../application/rule/methods/get/index.ts | 2 - .../rule/methods/get/schemas/index.ts | 1 - .../rule/methods/get/types/index.ts | 1 - .../application/rule/transforms/index.ts | 1 + ...ransform_rule_so_to_sanitized_rule.test.ts | 182 ++++++++++++++++++ .../transform_rule_so_to_sanitized_rule.ts | 76 ++++++++ .../alerting/server/rules_client.mock.ts | 2 +- .../server/rules_client/rules_client.ts | 10 +- .../fetch_rules_by_query_or_ids.ts | 2 +- .../api/rules/bulk_actions/route.test.ts | 2 +- 18 files changed, 323 insertions(+), 40 deletions(-) rename x-pack/platform/plugins/shared/alerting/server/application/rule/methods/{get/get_rules.test.ts => bulk_get/bulk_get_rules.test.ts} (83%) rename x-pack/platform/plugins/shared/alerting/server/application/rule/methods/{get/get_rules.ts => bulk_get/bulk_get_rules.ts} (84%) create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/index.ts rename x-pack/platform/plugins/shared/alerting/server/application/rule/methods/{get/schemas/get_rules_params_schema.ts => bulk_get/schemas/bulk_get_rules_params_schema.ts} (80%) create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/schemas/index.ts rename x-pack/platform/plugins/shared/alerting/server/application/rule/methods/{get/types/get_rules_params.ts => bulk_get/types/bulk_get_rules_params.ts} (69%) rename x-pack/platform/plugins/shared/alerting/server/application/rule/methods/{get/types/get_rules_response.ts => bulk_get/types/bulk_get_rules_response.ts} (88%) create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/types/index.ts create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/transform_rule_so_to_sanitized_rule.test.ts create mode 100644 x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/transform_rule_so_to_sanitized_rule.ts diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.test.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.test.ts similarity index 83% rename from x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.test.ts rename to x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.test.ts index ed147b2a556a8..d0ce40f572eee 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.test.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.test.ts @@ -6,18 +6,18 @@ */ import Boom from '@hapi/boom'; -import { transformToSanitizedRule } from './utils'; +import { transformRuleSoToSanitizedRule } from '../../transforms'; import { bulkGetRulesSo } from '../../../../data/rule'; -import { getRules } from './get_rules'; +import { bulkGetRules } from './bulk_get_rules'; import { rulesClientContextMock } from '../../../../rules_client/rules_client.mock'; -import type { GetRulesResponse } from './types/get_rules_response'; +import type { BulkGetRulesResponse } from './types/bulk_get_rules_response'; import type { RuleParams } from '../../types'; import { RuleAuditAction } from '../../../../rules_client/common/audit_events'; -import type { GetRulesParams } from './types'; +import type { BulkGetRulesParams } from './types'; -jest.mock('./utils', () => { +jest.mock('../../transforms', () => { return { - transformToSanitizedRule: jest.fn(), + transformRuleSoToSanitizedRule: jest.fn(), }; }); @@ -28,7 +28,7 @@ jest.mock('../../../../data/rule', () => { }); const rulesClientContext = rulesClientContextMock.create(); -const transformToSanitizedRuleMock = transformToSanitizedRule as jest.Mock; +const transformRuleSoToSanitizedRuleMock = transformRuleSoToSanitizedRule as jest.Mock; const bulkGetRulesSoMock = bulkGetRulesSo as jest.Mock; const ensureAuthorizedMock = rulesClientContext.authorization.ensureAuthorized as jest.Mock; const auditLoggerMock = rulesClientContext.auditLogger?.log as jest.Mock; @@ -58,15 +58,15 @@ const getTestRules = () => { }; }; -describe('getRules', () => { +describe('bulkGetRules', () => { let ruleIds: string[] = []; - let results: GetRulesResponse; + let results: BulkGetRulesResponse; let testRules: ReturnType; beforeEach(async () => { jest.resetAllMocks(); testRules = getTestRules(); ruleIds = testRules.all.map(({ id }) => id); - transformToSanitizedRuleMock.mockImplementation((_, rule) => { + transformRuleSoToSanitizedRuleMock.mockImplementation((_, rule) => { return { ...rule, sanitized: true, @@ -87,12 +87,12 @@ describe('getRules', () => { } }); - results = await getRules(rulesClientContext, { ids: ruleIds }); + results = await bulkGetRules(rulesClientContext, { ids: ruleIds }); }); it('should throw if called with invalid params', async () => { await expect( - getRules(rulesClientContext, {} as unknown as GetRulesParams) + bulkGetRules(rulesClientContext, {} as unknown as BulkGetRulesParams) ).rejects.toThrowErrorMatchingInlineSnapshot( '"Error validating get rules params - [ids]: expected value of type [array] but got [undefined]"' ); @@ -141,9 +141,9 @@ describe('getRules', () => { }); it('should attempt to sanitize the rules', () => { - expect(transformToSanitizedRuleMock).toHaveBeenCalledTimes(testRules.successful.length); + expect(transformRuleSoToSanitizedRuleMock).toHaveBeenCalledTimes(testRules.successful.length); testRules.successful.forEach((rule) => { - expect(transformToSanitizedRuleMock).toHaveBeenCalledWith(rulesClientContext, rule, {}); + expect(transformRuleSoToSanitizedRuleMock).toHaveBeenCalledWith(rulesClientContext, rule, {}); }); }); diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.ts similarity index 84% rename from x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.ts rename to x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.ts index 7d2bdbb5261b4..281bfedf01b10 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/get_rules.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.ts @@ -12,24 +12,24 @@ import { ReadOperations, AlertingAuthorizationEntity } from '../../../../authori import { ruleAuditEvent, RuleAuditAction } from '../../../../rules_client/common/audit_events'; import type { RulesClientContext } from '../../../../rules_client/types'; import { RULE_SAVED_OBJECT_TYPE } from '../../../../saved_objects'; -import type { GetRulesParams } from './types'; -import { getRulesParamsSchema } from './schemas'; +import type { BulkGetRulesParams } from './types'; +import { bulkGetRulesParamsSchema } from './schemas'; import type { RuleParams } from '../../types'; import { bulkGetRulesSo } from '../../../../data/rule'; -import { transformToSanitizedRule } from './utils'; -import type { GetRulesResponse } from './types/get_rules_response'; +import { transformRuleSoToSanitizedRule } from '../../transforms'; +import type { BulkGetRulesResponse } from './types/bulk_get_rules_response'; -export async function getRules( +export async function bulkGetRules( context: RulesClientContext, - params: GetRulesParams -): Promise> { + params: BulkGetRulesParams +): Promise> { try { - getRulesParamsSchema.validate(params); + bulkGetRulesParamsSchema.validate(params); } catch (error) { throw Boom.badRequest(`Error validating get rules params - ${error.message}`); } - const result: GetRulesResponse = { + const result: BulkGetRulesResponse = { rules: [], errors: [], }; @@ -109,7 +109,7 @@ export async function getRules( const paramsForTransform = omit(params, ['ids']); const transformedRules = await pMap( authorizedRuleSos, - (rule) => transformToSanitizedRule(context, rule, paramsForTransform), + (rule) => transformRuleSoToSanitizedRule(context, rule, paramsForTransform), { concurrency: 10 } ); result.rules.push(...transformedRules); diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/index.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/index.ts new file mode 100644 index 0000000000000..8c7d3cf304cf5 --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/index.ts @@ -0,0 +1,9 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +export type { BulkGetRulesParams } from './types'; +export { bulkGetRules } from './bulk_get_rules'; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/get_rules_params_schema.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/schemas/bulk_get_rules_params_schema.ts similarity index 80% rename from x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/get_rules_params_schema.ts rename to x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/schemas/bulk_get_rules_params_schema.ts index dd4a8f902593a..12b0ffbdd6088 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/get_rules_params_schema.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/schemas/bulk_get_rules_params_schema.ts @@ -7,8 +7,8 @@ import { schema } from '@kbn/config-schema'; -export const getRulesParamsSchema = schema.object({ - ids: schema.arrayOf(schema.string()), +export const bulkGetRulesParamsSchema = schema.object({ + ids: schema.arrayOf(schema.string(), { minSize: 1 }), includeLegacyId: schema.maybe(schema.boolean()), includeSnoozeData: schema.maybe(schema.boolean()), excludeFromPublicApi: schema.maybe(schema.boolean()), diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/schemas/index.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/schemas/index.ts new file mode 100644 index 0000000000000..fac91d4746172 --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/schemas/index.ts @@ -0,0 +1,8 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +export * from './bulk_get_rules_params_schema'; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_params.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/types/bulk_get_rules_params.ts similarity index 69% rename from x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_params.ts rename to x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/types/bulk_get_rules_params.ts index 8c0b355be0412..d72e0159d0df9 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_params.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/types/bulk_get_rules_params.ts @@ -6,6 +6,6 @@ */ import type { TypeOf } from '@kbn/config-schema'; -import type { getRulesParamsSchema } from '../schemas'; +import type { bulkGetRulesParamsSchema } from '../schemas'; -export type GetRulesParams = TypeOf; +export type BulkGetRulesParams = TypeOf; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_response.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/types/bulk_get_rules_response.ts similarity index 88% rename from x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_response.ts rename to x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/types/bulk_get_rules_response.ts index d18dcfa79551d..c07fe24f6fbab 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/get_rules_response.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/types/bulk_get_rules_response.ts @@ -8,7 +8,7 @@ import type { SanitizedRule, SanitizedRuleWithLegacyId } from '../../../../../types'; import type { RuleParams } from '../../../types'; -export interface GetRulesResponse { +export interface BulkGetRulesResponse { rules: Array | SanitizedRuleWithLegacyId>; errors: Array<{ id: string; error: { message: string; statusCode?: number } }>; } diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/types/index.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/types/index.ts new file mode 100644 index 0000000000000..eb4d3d9e4e47e --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/types/index.ts @@ -0,0 +1,9 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +export * from './bulk_get_rules_params'; +export * from './bulk_get_rules_response'; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/index.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/index.ts index a90254160e763..cd47bf0db31ab 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/index.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/index.ts @@ -6,6 +6,4 @@ */ export type { GetRuleParams } from './types'; -export type { GetRulesParams } from './types'; export { getRule } from './get_rule'; -export { getRules } from './get_rules'; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/index.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/index.ts index ad3a88772eebc..fed991d8a07b1 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/index.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/schemas/index.ts @@ -6,4 +6,3 @@ */ export * from './get_rule_params_schema'; -export * from './get_rules_params_schema'; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/index.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/index.ts index 686b6ea7e0c04..553499a994ff6 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/index.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/get/types/index.ts @@ -6,4 +6,3 @@ */ export * from './get_rule_params'; -export * from './get_rules_params'; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/index.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/index.ts index d3933385ae898..18ca3cfeed297 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/index.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/index.ts @@ -9,3 +9,4 @@ export { transformRuleAttributesToRuleDomain } from './transform_rule_attributes export { transformRuleDomainToRuleAttributes } from './transform_rule_domain_to_rule_attributes'; export { transformRuleDomainToRule } from './transform_rule_domain_to_rule'; export { transformRawActionsToDomainActions } from './transform_raw_actions_to_domain_actions'; +export { transformRuleSoToSanitizedRule } from './transform_rule_so_to_sanitized_rule'; diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/transform_rule_so_to_sanitized_rule.test.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/transform_rule_so_to_sanitized_rule.test.ts new file mode 100644 index 0000000000000..2935deb321fde --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/transform_rule_so_to_sanitized_rule.test.ts @@ -0,0 +1,182 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import { RecoveredActionGroup } from '../../../../common'; +import { rulesClientContextMock } from '../../../rules_client/rules_client.mock'; +import type { RulesClientContext } from '../../../rules_client/types'; +import { RULE_SAVED_OBJECT_TYPE } from '../../../saved_objects'; +import { transformRuleSoToSanitizedRule } from './transform_rule_so_to_sanitized_rule'; +import type { getRuleSo } from '../../../data/rule'; +import { formatLegacyActions } from '../../../rules_client/lib'; +import { AlertConsumers } from '@kbn/rule-data-utils'; + +type RuleSo = Awaited>; + +jest.mock('../../../rules_client/lib', () => { + return { + formatLegacyActions: jest.fn(), + }; +}); + +const formatLegacyActionsMock = formatLegacyActions as jest.Mock; + +const getTestRule = (overrides?: { consumer?: string }) => { + const attributes = { + alertTypeId: '123', + schedule: { interval: '10s' }, + params: { + bar: true, + }, + executionStatus: { + status: 'unknown', + lastExecutionDate: new Date('2020-08-20T19:23:38Z'), + }, + createdAt: new Date().toISOString(), + updatedAt: new Date().toISOString(), + actions: [ + { + group: 'default', + actionRef: 'action_0', + params: { + foo: true, + }, + }, + ], + notifyWhen: 'onActiveAlert', + consumer: overrides?.consumer, + }; + const ruleSo = { + id: '1', + type: RULE_SAVED_OBJECT_TYPE, + attributes, + references: [ + { + name: 'action_0', + type: 'action', + id: '1', + }, + ], + } as unknown as RuleSo; + + const sanitized = { + actions: attributes.actions.map((action) => ({ + actionTypeId: undefined, + group: action.group, + id: ruleSo.references.find((ref) => ref.name === action.actionRef)?.id, + params: action.params, + uuid: undefined, + })), + alertTypeId: attributes.alertTypeId, + artifacts: { + dashboards: [], + investigation_guide: { blob: '' }, + }, + createdAt: new Date(attributes.createdAt), + executionStatus: { + lastExecutionDate: new Date(attributes.executionStatus.lastExecutionDate), + status: attributes.executionStatus.status, + }, + id: ruleSo.id, + notifyWhen: attributes.notifyWhen, + params: { + ...attributes.params, + parameterThatIsSavedObjectId: '9', + }, + schedule: attributes.schedule, + systemActions: [], + updatedAt: new Date(attributes.updatedAt), + consumer: ruleSo.attributes.consumer, + }; + + return { + so: ruleSo, + sanitized, + }; +}; + +let rulesClientContext: RulesClientContext; +let expectedSanitizedRule: ReturnType['sanitized']; +let result: Awaited>; + +const options = { includeLegacyId: true, includeSnoozeData: true, excludeFromPublicApi: true }; + +describe('transformRuleSoToSanitizedRule', () => { + beforeEach(async () => { + jest.clearAllMocks(); + + rulesClientContext = rulesClientContextMock.create(); + const injectReferencesFn = jest.fn().mockReturnValue({ + bar: true, + parameterThatIsSavedObjectId: '9', + }); + const getRuleTypeRegistryMock = rulesClientContext.ruleTypeRegistry.get as jest.Mock; + getRuleTypeRegistryMock.mockImplementation(() => ({ + id: '123', + name: 'Test', + actionGroups: [{ id: 'default', name: 'Default' }], + recoveryActionGroup: RecoveredActionGroup, + defaultActionGroupId: 'default', + minimumLicenseRequired: 'basic', + isExportable: true, + async executor() { + return { state: {} }; + }, + category: 'test', + producer: 'alerts', + solution: 'stack', + useSavedObjectReferences: { + extractReferences: jest.fn(), + injectReferences: injectReferencesFn, + }, + validate: { + params: { validate: () => {} }, + }, + validLegacyConsumers: [], + })); + + const { so, sanitized } = getTestRule(); + expectedSanitizedRule = sanitized; + + result = await transformRuleSoToSanitizedRule(rulesClientContext, so, options); + }); + + it('should transform the rule saved object to a SanitizedRule', () => { + expect(result).toEqual(expectedSanitizedRule); + }); + + it('should handle validation errors on the rule domain', () => { + expect(rulesClientContext.logger.warn).toHaveBeenCalledWith( + 'Error validating get rule domain object for id: 1, Error: [enabled]: expected value of type [boolean] but got [undefined]' + ); + }); + + it('should not format legacy actions for non SIEM rules', () => { + expect(formatLegacyActionsMock).not.toHaveBeenCalled(); + }); + + describe('when the rule is a SIEM rule', () => { + let sanitizedRule: ReturnType['sanitized']; + beforeEach(async () => { + const { so, sanitized } = getTestRule({ consumer: AlertConsumers.SIEM }); + sanitizedRule = sanitized; + expectedSanitizedRule = {} as typeof expectedSanitizedRule; + formatLegacyActionsMock.mockResolvedValueOnce([expectedSanitizedRule]); + result = await transformRuleSoToSanitizedRule(rulesClientContext, so, options); + }); + it('should attempt to format legacy actions', () => { + expect(formatLegacyActionsMock).toHaveBeenCalledTimes(1); + expect(formatLegacyActionsMock).toHaveBeenCalledWith([sanitizedRule], { + savedObjectsClient: rulesClientContext.unsecuredSavedObjectsClient, + logger: rulesClientContext.logger, + }); + }); + + it('should return the migrated rule', () => { + expect(result).toBe(expectedSanitizedRule); + }); + }); +}); diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/transform_rule_so_to_sanitized_rule.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/transform_rule_so_to_sanitized_rule.ts new file mode 100644 index 0000000000000..5c6ee78f0fa44 --- /dev/null +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/transforms/transform_rule_so_to_sanitized_rule.ts @@ -0,0 +1,76 @@ +/* + * 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; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +import { AlertConsumers } from '@kbn/rule-data-utils'; +import type { getRuleSo } from '../../../data/rule'; +import { formatLegacyActions } from '../../../rules_client/lib'; +import type { RulesClientContext } from '../../../rules_client/types'; +import type { Rule as DeprecatedRule, SanitizedRule } from '../../../types'; +import { ruleDomainSchema } from '../schemas'; +import { transformRuleAttributesToRuleDomain } from './transform_rule_attributes_to_rule_domain'; +import { transformRuleDomainToRule } from './transform_rule_domain_to_rule'; +import type { RuleParams } from '../types'; + +interface TransformRuleSoToSanitizedRuleOptions { + includeLegacyId?: boolean; + includeSnoozeData?: boolean; + excludeFromPublicApi?: boolean; +} + +type RuleSo = Awaited>; + +export async function transformRuleSoToSanitizedRule( + context: RulesClientContext, + ruleSo: RuleSo, + options: TransformRuleSoToSanitizedRuleOptions +) { + const { + includeLegacyId = false, + includeSnoozeData = false, + excludeFromPublicApi = false, + } = options; + const ruleType = context.ruleTypeRegistry.get(ruleSo.attributes.alertTypeId); + + const ruleDomain = transformRuleAttributesToRuleDomain( + ruleSo.attributes, + { + id: ruleSo.id, + logger: context.logger, + ruleType, + references: ruleSo.references, + includeSnoozeData, + }, + context.isSystemAction + ); + + // Try to validate created rule, but don't throw. + try { + ruleDomainSchema.validate(ruleDomain); + } catch (e) { + context.logger.warn(`Error validating get rule domain object for id: ${ruleSo.id}, ${e}`); + } + + // Convert domain rule to rule (Remove certain properties) + const rule = transformRuleDomainToRule(ruleDomain, { + isPublic: excludeFromPublicApi, + includeLegacyId, + }); + + // format legacy actions for SIEM rules + if (ruleSo.attributes.consumer === AlertConsumers.SIEM) { + const [migratedRule] = await formatLegacyActions([rule as DeprecatedRule], { + savedObjectsClient: context.unsecuredSavedObjectsClient, + logger: context.logger, + }); + + return migratedRule; + } + + // TODO (http-versioning): Remove this cast, this enables us to move forward + // without fixing all of other solution types + return rule as SanitizedRule; +} diff --git a/x-pack/platform/plugins/shared/alerting/server/rules_client.mock.ts b/x-pack/platform/plugins/shared/alerting/server/rules_client.mock.ts index 5c6ea245c2e18..01127e358c888 100644 --- a/x-pack/platform/plugins/shared/alerting/server/rules_client.mock.ts +++ b/x-pack/platform/plugins/shared/alerting/server/rules_client.mock.ts @@ -47,7 +47,7 @@ const createRulesClientMock = () => { findBackfill: jest.fn(), deleteBackfill: jest.fn(), getSpaceId: jest.fn(), - bulkGet: jest.fn(), + bulkGetRules: jest.fn(), bulkEdit: jest.fn(), bulkDeleteRules: jest.fn(), bulkEnableRules: jest.fn(), diff --git a/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.ts b/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.ts index e19734123fb08..221c06ea69ae3 100644 --- a/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.ts +++ b/x-pack/platform/plugins/shared/alerting/server/rules_client/rules_client.ts @@ -22,8 +22,10 @@ import type { SnoozeRuleOptions } from '../application/rule/methods/snooze'; import { snoozeRule } from '../application/rule/methods/snooze'; import type { UnsnoozeParams } from '../application/rule/methods/unsnooze'; import { unsnoozeRule } from '../application/rule/methods/unsnooze'; -import type { GetRuleParams, GetRulesParams } from '../application/rule/methods/get'; -import { getRule, getRules } from '../application/rule/methods/get'; +import type { GetRuleParams } from '../application/rule/methods/get'; +import type { BulkGetRulesParams } from '../application/rule/methods/bulk_get'; +import { getRule } from '../application/rule/methods/get'; +import { bulkGetRules } from '../application/rule/methods/bulk_get'; import type { ResolveParams } from '../application/rule/methods/resolve'; import { resolveRule } from '../application/rule/methods/resolve'; import type { GetAlertStateParams } from './methods/get_alert_state'; @@ -170,8 +172,8 @@ export class RulesClient { public getActionErrorLogWithAuth = (params: GetActionErrorLogByIdParams) => getActionErrorLogWithAuth(this.context, params); - public bulkGet = (params: GetRulesParams) => - getRules(this.context, params); + public bulkGetRules = (params: BulkGetRulesParams) => + bulkGetRules(this.context, params); public bulkDeleteRules = (options: BulkDeleteRulesRequestBody) => bulkDeleteRules(this.context, options); public bulkEdit = (options: BulkEditOptions) => diff --git a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts index cf2d8b214acdf..b5de6f514e887 100644 --- a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts +++ b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts @@ -26,7 +26,7 @@ export const fetchRulesByQueryOrIds = async ({ gapRange?: { start: string; end: string }; }): Promise> => { if (ids) { - const { rules, errors } = await rulesClient.bulkGet({ ids }); + const { rules, errors } = await rulesClient.bulkGetRules({ ids }); return { results: rules.map((rule) => ({ item: rule.id, diff --git a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.test.ts b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.test.ts index 64b1b56f0f4c4..e4d56bb24ec4f 100644 --- a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.test.ts +++ b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/route.test.ts @@ -37,7 +37,7 @@ describe('Perform bulk action route', () => { server = serverMock.create(); ({ clients, context } = requestContextMock.createTools()); ml = mlServicesMock.createSetupContract(); - bulkGetRulesMock = (await context.alerting.getRulesClient()).bulkGet as jest.Mock; + bulkGetRulesMock = (await context.alerting.getRulesClient()).bulkGetRules as jest.Mock; clients.rulesClient.find.mockResolvedValue(getFindResultWithSingleHit()); clients.rulesClient.bulkDisableRules.mockResolvedValue({ From 614d8e09f27672b151e99931ebdbe6140b945694 Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Mon, 9 Jun 2025 13:34:38 +0200 Subject: [PATCH 04/14] use the same authorization logic that other bulk actions use --- .../methods/bulk_get/bulk_get_rules.test.ts | 51 +++++++++-------- .../rule/methods/bulk_get/bulk_get_rules.ts | 57 ++++++++----------- .../lib/check_authorization_and_get_total.ts | 6 +- .../alerting/server/rules_client/types.ts | 2 +- 4 files changed, 56 insertions(+), 60 deletions(-) diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.test.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.test.ts index d0ce40f572eee..b2d062c708bc4 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.test.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.test.ts @@ -5,7 +5,6 @@ * 2.0. */ -import Boom from '@hapi/boom'; import { transformRuleSoToSanitizedRule } from '../../transforms'; import { bulkGetRulesSo } from '../../../../data/rule'; import { bulkGetRules } from './bulk_get_rules'; @@ -14,6 +13,10 @@ import type { BulkGetRulesResponse } from './types/bulk_get_rules_response'; import type { RuleParams } from '../../types'; import { RuleAuditAction } from '../../../../rules_client/common/audit_events'; import type { BulkGetRulesParams } from './types'; +import { + getAuthorizationFilter, + checkAuthorizationAndGetTotal, +} from '../../../../rules_client/lib'; jest.mock('../../transforms', () => { return { @@ -27,11 +30,19 @@ jest.mock('../../../../data/rule', () => { }; }); +jest.mock('../../../../rules_client/lib', () => { + return { + getAuthorizationFilter: jest.fn(), + checkAuthorizationAndGetTotal: jest.fn(), + }; +}); + const rulesClientContext = rulesClientContextMock.create(); const transformRuleSoToSanitizedRuleMock = transformRuleSoToSanitizedRule as jest.Mock; const bulkGetRulesSoMock = bulkGetRulesSo as jest.Mock; -const ensureAuthorizedMock = rulesClientContext.authorization.ensureAuthorized as jest.Mock; const auditLoggerMock = rulesClientContext.auditLogger?.log as jest.Mock; +const getAuthorizationFilterMock = getAuthorizationFilter as jest.Mock; +const checkAuthorizationAndGetTotalMock = checkAuthorizationAndGetTotal as jest.Mock; const getRule = (id: string, alertTypeId: string, consumer: string) => ({ id, @@ -48,13 +59,10 @@ const getTestRules = () => { const erroredFetchingSo = [getRuleErroredFetchingSo('5')]; - const erroredAccess = [getRule('6', 'some-forbidden-alert-type', 'some-consumer-1')]; - return { successful, erroredFetchingSo, - erroredAccess, - all: [...successful, ...erroredFetchingSo, ...erroredAccess], + all: [...successful, ...erroredFetchingSo], }; }; @@ -77,15 +85,9 @@ describe('bulkGetRules', () => { saved_objects: testRules.all, }); - ensureAuthorizedMock.mockImplementation(async ({ ruleTypeId, consumer }) => { - const errorRule = testRules.erroredAccess.find( - (rule) => - rule.attributes.alertTypeId === ruleTypeId && rule.attributes.consumer === consumer - ); - if (errorRule) { - throw Boom.forbidden('Unauthorized'); - } - }); + getAuthorizationFilterMock.mockResolvedValue([]); + + checkAuthorizationAndGetTotalMock.mockResolvedValueOnce({ total: 0 }); results = await bulkGetRules(rulesClientContext, { ids: ruleIds }); }); @@ -98,6 +100,14 @@ describe('bulkGetRules', () => { ); }); + it('should throw an error if it fails to verify the user access to the rules', async () => { + const authError = new Error('Some auth error'); + checkAuthorizationAndGetTotalMock.mockRejectedValueOnce(authError); + await expect( + bulkGetRules(rulesClientContext, { ids: ruleIds } as unknown as BulkGetRulesParams) + ).rejects.toThrowError(authError); + }); + it('should attempt to resolve rules', () => { expect(bulkGetRulesSoMock).toHaveBeenCalledTimes(1); expect(bulkGetRulesSoMock).toHaveBeenCalledWith({ @@ -107,7 +117,7 @@ describe('bulkGetRules', () => { }); it('should audit log', () => { - expect(auditLoggerMock).toHaveBeenCalledTimes(6); + expect(auditLoggerMock).toHaveBeenCalledTimes(5); const assertAuditLogCall = (id: string, name?: string, errorMsg?: string) => { const errorObj = errorMsg ? expect.objectContaining({ message: errorMsg }) : undefined; const ruleObj: { id: string; name?: string } = { id }; @@ -134,10 +144,6 @@ describe('bulkGetRules', () => { testRules.erroredFetchingSo.forEach(({ id, error }) => { assertAuditLogCall(id, undefined, error.message); }); - - testRules.erroredAccess.forEach(({ id }) => { - assertAuditLogCall(id, undefined, 'Unauthorized'); - }); }); it('should attempt to sanitize the rules', () => { @@ -153,9 +159,6 @@ describe('bulkGetRules', () => { }); it('should return any errors that occurred', () => { - expect(results.errors).toEqual([ - ...testRules.erroredFetchingSo, - ...testRules.erroredAccess.map(({ id }) => ({ id, error: new Error('Unauthorized') })), - ]); + expect(results.errors).toEqual(testRules.erroredFetchingSo); }); }); diff --git a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.ts b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.ts index 281bfedf01b10..4ae4bb17ac62b 100644 --- a/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.ts +++ b/x-pack/platform/plugins/shared/alerting/server/application/rule/methods/bulk_get/bulk_get_rules.ts @@ -7,8 +7,9 @@ import Boom from '@hapi/boom'; import pMap from 'p-map'; -import { chunk, groupBy, mapValues, omit } from 'lodash'; -import { ReadOperations, AlertingAuthorizationEntity } from '../../../../authorization'; +import { chunk, omit } from 'lodash'; +import type { KueryNode } from '@kbn/es-query'; +import { nodeBuilder } from '@kbn/es-query'; import { ruleAuditEvent, RuleAuditAction } from '../../../../rules_client/common/audit_events'; import type { RulesClientContext } from '../../../../rules_client/types'; import { RULE_SAVED_OBJECT_TYPE } from '../../../../saved_objects'; @@ -18,6 +19,11 @@ import type { RuleParams } from '../../types'; import { bulkGetRulesSo } from '../../../../data/rule'; import { transformRuleSoToSanitizedRule } from '../../transforms'; import type { BulkGetRulesResponse } from './types/bulk_get_rules_response'; +import { convertRuleIdsToKueryNode } from '../../../../lib'; +import { + getAuthorizationFilter, + checkAuthorizationAndGetTotal, +} from '../../../../rules_client/lib'; export async function bulkGetRules( context: RulesClientContext, @@ -29,6 +35,19 @@ export async function bulkGetRules( throw Boom.badRequest(`Error validating get rules params - ${error.message}`); } + const kueryNodeFilter = convertRuleIdsToKueryNode(params.ids); + const authorizationFilter = await getAuthorizationFilter(context, { action: 'GET' }); + + const kueryNodeFilterWithAuth = + authorizationFilter && kueryNodeFilter + ? nodeBuilder.and([kueryNodeFilter, authorizationFilter as KueryNode]) + : kueryNodeFilter; + + await checkAuthorizationAndGetTotal(context, { + filter: kueryNodeFilterWithAuth, + action: 'GET', + }); + const result: BulkGetRulesResponse = { rules: [], errors: [], @@ -57,37 +76,7 @@ export async function bulkGetRules( } ); - const alertTypes = mapValues( - groupBy(savedObjects, (rule) => `${rule.attributes.alertTypeId}<>${rule.attributes.consumer}`), - (groupedRules) => ({ - alertTypeId: groupedRules[0].attributes.alertTypeId, - consumer: groupedRules[0].attributes.consumer, - rules: groupedRules, - }) - ); - - const authorizedRuleSos: (typeof alertTypes)[0]['rules'] = []; - for (const { alertTypeId, consumer, rules } of Object.values(alertTypes)) { - try { - await context.authorization.ensureAuthorized({ - ruleTypeId: alertTypeId, - consumer, - operation: ReadOperations.Get, - entity: AlertingAuthorizationEntity.Rule, - }); - - authorizedRuleSos.push(...rules); - } catch (error) { - rules.forEach((rule) => { - result.errors.push({ - id: rule.id, - error, - }); - }); - } - } - - authorizedRuleSos.forEach((rule) => { + savedObjects.forEach((rule) => { context.auditLogger?.log( ruleAuditEvent({ action: RuleAuditAction.GET, @@ -108,7 +97,7 @@ export async function bulkGetRules( const paramsForTransform = omit(params, ['ids']); const transformedRules = await pMap( - authorizedRuleSos, + savedObjects, (rule) => transformRuleSoToSanitizedRule(context, rule, paramsForTransform), { concurrency: 10 } ); diff --git a/x-pack/platform/plugins/shared/alerting/server/rules_client/lib/check_authorization_and_get_total.ts b/x-pack/platform/plugins/shared/alerting/server/rules_client/lib/check_authorization_and_get_total.ts index 761de9765d5d8..aac3ba5a5ce42 100644 --- a/x-pack/platform/plugins/shared/alerting/server/rules_client/lib/check_authorization_and_get_total.ts +++ b/x-pack/platform/plugins/shared/alerting/server/rules_client/lib/check_authorization_and_get_total.ts @@ -10,7 +10,7 @@ import Boom from '@hapi/boom'; import type { KueryNode } from '@kbn/es-query'; import { withSpan } from '@kbn/apm-utils'; import type { RawRule } from '../../types'; -import type { ReadOperations } from '../../authorization'; +import { ReadOperations } from '../../authorization'; import { WriteOperations, AlertingAuthorizationEntity } from '../../authorization'; import type { BulkAction, RuleBulkOperationAggregation } from '../types'; import { @@ -47,6 +47,10 @@ export const checkAuthorizationAndGetTotal = async ( WriteOperation: WriteOperations.BulkDisable, RuleAuditAction: RuleAuditAction.DISABLE, }, + GET: { + WriteOperation: ReadOperations.Get, + RuleAuditAction: RuleAuditAction.GET, + }, }; const { aggregations, total } = await withSpan( diff --git a/x-pack/platform/plugins/shared/alerting/server/rules_client/types.ts b/x-pack/platform/plugins/shared/alerting/server/rules_client/types.ts index b00bafeca43c9..62b27e4efc342 100644 --- a/x-pack/platform/plugins/shared/alerting/server/rules_client/types.ts +++ b/x-pack/platform/plugins/shared/alerting/server/rules_client/types.ts @@ -168,7 +168,7 @@ export interface BulkOperationError { }; } -export type BulkAction = 'DELETE' | 'ENABLE' | 'DISABLE'; +export type BulkAction = 'DELETE' | 'ENABLE' | 'DISABLE' | 'GET'; export interface RuleBulkOperationAggregation { alertTypeId: { From 25d10730998d307737fcbad2cba5fd60ebda1121 Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Mon, 9 Jun 2025 14:06:08 +0200 Subject: [PATCH 05/14] handle the case when toScheduledItem throws an error while updating gaps --- .../lib/rule_gaps/update/update_gaps.test.ts | 59 +++++++++++++++++++ .../lib/rule_gaps/update/update_gaps.ts | 11 +++- 2 files changed, 69 insertions(+), 1 deletion(-) diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.test.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.test.ts index b17d89a1cccde..10e65b6dadce6 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.test.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.test.ts @@ -330,6 +330,65 @@ describe('updateGaps', () => { expect(calculateGapStateFromAllBackfills).not.toHaveBeenCalled(); }); + it('should handle invalid scheduled items', async () => { + const testGap = createTestGap(); + (findGapsSearchAfter as jest.Mock).mockResolvedValue({ + data: [testGap], + total: 1, + pitId: 'test-pit-id', + searchAfter: undefined, + }); + + await updateGaps({ + ruleId: 'test-rule-id', + start: new Date('2024-01-01T00:00:00.000Z'), + end: new Date('2024-01-01T01:00:00.000Z'), + eventLogger: mockEventLogger, + eventLogClient: mockEventLogClient, + logger: mockLogger, + savedObjectsRepository: mockSavedObjectsRepository, + backfillSchedule: [ + { + runAt: '2024-01-01T00:30:00.000Z', + interval: '30m', + status: adHocRunStatus.COMPLETE, + }, + { + runAt: '2024-01-01T00:35:00.000Z', + interval: 'INVALID', + status: adHocRunStatus.COMPLETE, + }, + { + runAt: '2024-01-01T00:40:00.000Z', + interval: '10m', + status: adHocRunStatus.COMPLETE, + }, + ], + backfillClient: mockBackfillClient, + actionsClient: mockActionsClient, + }); + + expect(updateGapFromSchedule).toHaveBeenCalledWith({ + gap: testGap, + scheduledItems: [ + { + from: new Date('2024-01-01T00:00:00.000Z'), + to: new Date('2024-01-01T00:30:00.000Z'), + status: adHocRunStatus.COMPLETE, + }, + { + from: new Date('2024-01-01T00:30:00.000Z'), + to: new Date('2024-01-01T00:40:00.000Z'), + status: adHocRunStatus.COMPLETE, + }, + ], + }); + expect(mockLogger.error).toHaveBeenCalledWith( + 'Error processing a scheduled item while updating gaps: Invalid duration "INVALID". Durations must be of the form {number}x. Example: 5s, 5m, 5h or 5d"' + ); + expect(calculateGapStateFromAllBackfills).not.toHaveBeenCalled(); + }); + it('should trigger refetch when shouldRefetchAllBackfills is true', async () => { const testGap = createTestGap(); (findGapsSearchAfter as jest.Mock).mockResolvedValue({ diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts index 24069cad32130..bc676c81a3ff4 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts @@ -119,7 +119,16 @@ const updateGapBatch = async ( try { // Prepare all gaps for update const updatedGaps: Gap[] = []; - const scheduledItems = backfillSchedule?.map(toScheduledItem) ?? []; + const scheduledItems = (backfillSchedule ?? []) + .map((backfill) => { + try { + return toScheduledItem(backfill); + } catch (error) { + logger.error(`Error processing a scheduled item while updating gaps: ${error.message}`); + return undefined; + } + }) + .filter((scheduledItem) => scheduledItem !== undefined); await withSpan({ name: 'updateGaps.prepareGapsForUpdate', type: 'rule' }, async () => { for (const { gap, scheduled } of findOverlappingIntervals(gaps, scheduledItems)) { // we do async request only if there errors in backfill or no backfill schedule From 070017a93804f4aec36e119e7887640114ae2484 Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Mon, 9 Jun 2025 14:13:39 +0200 Subject: [PATCH 06/14] add unit tests for clipDateInterval --- .../lib/rule_gaps/gap/interval_utils.test.ts | 29 +++++++++++++++++++ .../lib/rule_gaps/gap/interval_utils.ts | 11 ++++--- .../server/lib/rule_gaps/update/utils.ts | 4 +-- 3 files changed, 38 insertions(+), 6 deletions(-) diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.test.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.test.ts index 6bf13a2ee9152..0c25c1db695f2 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.test.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.test.ts @@ -15,6 +15,7 @@ import { normalizeInterval, denormalizeInterval, clipInterval, + clipDateInterval, } from './interval_utils'; import type { Interval, StringInterval } from '../types'; @@ -260,4 +261,32 @@ describe('interval_utils', () => { expect(clipInterval(interval, boundary)).toBeNull(); }); }); + + describe('clipDateInterval', () => { + it('clips date interval to boundary', () => { + const expected = { + start: new Date('2025-01-01T12:00:00Z'), + end: new Date('2025-01-01T12:30:00Z'), + }; + expect( + clipDateInterval( + new Date('2025-01-01T11:00:00Z'), + new Date('2025-01-01T13:00:00Z'), + new Date('2025-01-01T12:00:00Z'), + new Date('2025-01-01T12:30:00Z') + ) + ).toEqual(expected); + }); + + it('returns null when no overlap with boundary', () => { + expect( + clipDateInterval( + new Date('2025-01-01T11:00:00Z'), + new Date('2025-01-01T11:30:00Z'), + new Date('2025-01-01T12:00:00Z'), + new Date('2025-01-01T12:30:00Z') + ) + ).toBeNull(); + }); + }); }); diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.ts index 5f7af3e4dc0d6..b41ad9127084c 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/gap/interval_utils.ts @@ -205,11 +205,10 @@ export const denormalizeInterval = (interval: Interval): StringInterval => { }; /** - * Clips an interval to ensure it falls within the given boundary range. - * If there's no overlap, returns null. + * Conveninence function that clips an `Interval` given an `Interval` boundary */ export const clipInterval = (interval: Interval, boundary: Interval): Interval | null => { - const clipped = clipDateIntervals(interval.gte, interval.lte, boundary.gte, boundary.lte); + const clipped = clipDateInterval(interval.gte, interval.lte, boundary.gte, boundary.lte); if (clipped === null) { return null; @@ -218,7 +217,11 @@ export const clipInterval = (interval: Interval, boundary: Interval): Interval | return { gte: clipped.start, lte: clipped.end }; }; -export const clipDateIntervals = ( +/** + * Clips an date interval to ensure it falls within the given boundary range. + * If there's no overlap, returns null. + */ +export const clipDateInterval = ( start: Date, end: Date, boundaryStart: Date, diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.ts index 49bff67ef9900..e4a15a9641008 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/utils.ts @@ -7,7 +7,7 @@ import type { BackfillSchedule } from '../../../application/backfill/result/types'; import { parseDuration } from '../../../../common'; -import { clipDateIntervals } from '../gap/interval_utils'; +import { clipDateInterval } from '../gap/interval_utils'; import type { Gap } from '../gap'; export interface ScheduledItem { @@ -62,7 +62,7 @@ const findEarliestOverlapping = ( }; const clipScheduled = (startMs: number, endMs: number, scheduledItem: ScheduledItem) => { - const clipped = clipDateIntervals( + const clipped = clipDateInterval( scheduledItem.from, scheduledItem.to, new Date(startMs), From 0e01f00f1ec7ca15f36a9c1915411efca3f815b1 Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Mon, 9 Jun 2025 14:06:08 +0200 Subject: [PATCH 07/14] handle the case when toScheduledItem throws an error while updating gaps --- .../shared/alerting/server/lib/rule_gaps/update/update_gaps.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts index bc676c81a3ff4..63395cbdbdf4c 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts @@ -128,7 +128,7 @@ const updateGapBatch = async ( return undefined; } }) - .filter((scheduledItem) => scheduledItem !== undefined); + .filter((scheduledItem): scheduledItem is ScheduledItem => scheduledItem !== undefined); await withSpan({ name: 'updateGaps.prepareGapsForUpdate', type: 'rule' }, async () => { for (const { gap, scheduled } of findOverlappingIntervals(gaps, scheduledItems)) { // we do async request only if there errors in backfill or no backfill schedule From b54e2255cdc6d895b54f5ca95da2f936a3abe0a6 Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Tue, 10 Jun 2025 19:10:31 +0200 Subject: [PATCH 08/14] Handle the case when bulkGetRules does not return a summary when an exception is thrown --- .../fetch_rules_by_query_or_ids.ts | 57 +++++++++++++------ 1 file changed, 40 insertions(+), 17 deletions(-) diff --git a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts index b5de6f514e887..1ff04f1d10a40 100644 --- a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts +++ b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts @@ -26,23 +26,46 @@ export const fetchRulesByQueryOrIds = async ({ gapRange?: { start: string; end: string }; }): Promise> => { if (ids) { - const { rules, errors } = await rulesClient.bulkGetRules({ ids }); - return { - results: rules.map((rule) => ({ - item: rule.id, - result: rule, - })), - errors: errors.map(({ id, error }) => { - let message = 'Error resolving the rule'; - if (error.statusCode === 404) { - message = 'Rule not found'; - } - return { - item: id, - error: new Error(message), - }; - }), - }; + const fallbackErrorMessage = 'Error resolving the rule' + try { + const { rules, errors } = await rulesClient.bulkGetRules({ ids }); + return { + results: rules.map((rule) => ({ + item: rule.id, + result: rule, + })), + errors: errors.map(({ id, error }) => { + let message = fallbackErrorMessage + if (error.statusCode === 404) { + message = 'Rule not found'; + } + return { + item: id, + error: new Error(message), + }; + }), + }; + } catch (error) { + // When there is an authorization error or it doesn't resolve any rule, + // bulkGetRules will not return a partial object but throw an error instead. + let message = error.message || fallbackErrorMessage + if (error.message === 'No rules found for bulk get') { + message = 'Rule not found' + } + return { + results: [], + errors: ids.map( + (id) => { + return { + item: id, + // We do this to remove any status code set by the bulkGetRules client + error: new Error(message) + } + } + ) + }; + } + } let ruleIdsWithGaps: string[] | undefined; From 58a447254507c2224e841a207890c52cd8c659c0 Mon Sep 17 00:00:00 2001 From: kibanamachine <42973632+kibanamachine@users.noreply.github.com> Date: Tue, 10 Jun 2025 17:33:28 +0000 Subject: [PATCH 09/14] [CI] Auto-commit changed files from 'node scripts/eslint --no-cache --fix' --- .../fetch_rules_by_query_or_ids.ts | 27 +++++++++---------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts index 1ff04f1d10a40..f156c177befef 100644 --- a/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts +++ b/x-pack/solutions/security/plugins/security_solution/server/lib/detection_engine/rule_management/api/rules/bulk_actions/fetch_rules_by_query_or_ids.ts @@ -26,7 +26,7 @@ export const fetchRulesByQueryOrIds = async ({ gapRange?: { start: string; end: string }; }): Promise> => { if (ids) { - const fallbackErrorMessage = 'Error resolving the rule' + const fallbackErrorMessage = 'Error resolving the rule'; try { const { rules, errors } = await rulesClient.bulkGetRules({ ids }); return { @@ -35,7 +35,7 @@ export const fetchRulesByQueryOrIds = async ({ result: rule, })), errors: errors.map(({ id, error }) => { - let message = fallbackErrorMessage + let message = fallbackErrorMessage; if (error.statusCode === 404) { message = 'Rule not found'; } @@ -46,26 +46,23 @@ export const fetchRulesByQueryOrIds = async ({ }), }; } catch (error) { - // When there is an authorization error or it doesn't resolve any rule, + // When there is an authorization error or it doesn't resolve any rule, // bulkGetRules will not return a partial object but throw an error instead. - let message = error.message || fallbackErrorMessage + let message = error.message || fallbackErrorMessage; if (error.message === 'No rules found for bulk get') { - message = 'Rule not found' + message = 'Rule not found'; } return { results: [], - errors: ids.map( - (id) => { - return { - item: id, - // We do this to remove any status code set by the bulkGetRules client - error: new Error(message) - } - } - ) + errors: ids.map((id) => { + return { + item: id, + // We do this to remove any status code set by the bulkGetRules client + error: new Error(message), + }; + }), }; } - } let ruleIdsWithGaps: string[] | undefined; From 77400d1490c7fdf45270c74930fccec8b8991b9f Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Wed, 11 Jun 2025 17:17:18 +0200 Subject: [PATCH 10/14] Add BulkGet read operation and audit action --- .../plugins/shared/alerting/server/authorization/types.ts | 1 + .../alerting/server/rules_client/common/audit_events.ts | 3 +++ .../rules_client/lib/check_authorization_and_get_total.ts | 4 ++-- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/x-pack/platform/plugins/shared/alerting/server/authorization/types.ts b/x-pack/platform/plugins/shared/alerting/server/authorization/types.ts index 8668884463667..f01fc450c90ed 100644 --- a/x-pack/platform/plugins/shared/alerting/server/authorization/types.ts +++ b/x-pack/platform/plugins/shared/alerting/server/authorization/types.ts @@ -12,6 +12,7 @@ export enum AlertingAuthorizationEntity { export enum ReadOperations { Get = 'get', + BulkGet = 'bulkGet', GetRuleState = 'getRuleState', GetAlertSummary = 'getAlertSummary', GetExecutionLog = 'getExecutionLog', diff --git a/x-pack/platform/plugins/shared/alerting/server/rules_client/common/audit_events.ts b/x-pack/platform/plugins/shared/alerting/server/rules_client/common/audit_events.ts index 416aad44c05d0..5163462ac2bf7 100644 --- a/x-pack/platform/plugins/shared/alerting/server/rules_client/common/audit_events.ts +++ b/x-pack/platform/plugins/shared/alerting/server/rules_client/common/audit_events.ts @@ -13,6 +13,7 @@ import { AD_HOC_RUN_SAVED_OBJECT_TYPE } from '../../saved_objects'; export enum RuleAuditAction { CREATE = 'rule_create', GET = 'rule_get', + BULK_GET = 'rule_bulk_get', RESOLVE = 'rule_resolve', UPDATE = 'rule_update', UPDATE_API_KEY = 'rule_update_api_key', @@ -55,6 +56,7 @@ type VerbsTuple = [string, string, string]; const ruleEventVerbs: Record = { rule_create: ['create', 'creating', 'created'], rule_get: ['access', 'accessing', 'accessed'], + rule_bulk_get: ['bulk access', 'bulk accessing', 'bulk accessed'], rule_resolve: ['access', 'accessing', 'accessed'], rule_update: ['update', 'updating', 'updated'], rule_bulk_edit: ['update', 'updating', 'updated'], @@ -131,6 +133,7 @@ const adHocRunEventVerbs: Record = { const ruleEventTypes: Record> = { rule_create: 'creation', rule_get: 'access', + rule_bulk_get: 'access', rule_resolve: 'access', rule_update: 'change', rule_bulk_edit: 'change', diff --git a/x-pack/platform/plugins/shared/alerting/server/rules_client/lib/check_authorization_and_get_total.ts b/x-pack/platform/plugins/shared/alerting/server/rules_client/lib/check_authorization_and_get_total.ts index aac3ba5a5ce42..d1cecd1cd2740 100644 --- a/x-pack/platform/plugins/shared/alerting/server/rules_client/lib/check_authorization_and_get_total.ts +++ b/x-pack/platform/plugins/shared/alerting/server/rules_client/lib/check_authorization_and_get_total.ts @@ -48,8 +48,8 @@ export const checkAuthorizationAndGetTotal = async ( RuleAuditAction: RuleAuditAction.DISABLE, }, GET: { - WriteOperation: ReadOperations.Get, - RuleAuditAction: RuleAuditAction.GET, + WriteOperation: ReadOperations.BulkGet, + RuleAuditAction: RuleAuditAction.BULK_GET, }, }; From 0255e7f4c5286e7fb150c77d3a6b73d8bdaf6bba Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Wed, 11 Jun 2025 17:52:22 +0200 Subject: [PATCH 11/14] handle exceptions thrown by toScheduledItem --- .../update/calculate_gaps_state.test.ts | 81 ++++++++++++++++++- .../rule_gaps/update/calculate_gaps_state.ts | 16 +++- .../lib/rule_gaps/update/update_gaps.ts | 8 +- 3 files changed, 99 insertions(+), 6 deletions(-) diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.test.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.test.ts index 99061527e1488..afa53f488aaec 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.test.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.test.ts @@ -4,20 +4,38 @@ * 2.0; you may not use this file except in compliance with the Elastic License * 2.0. */ - +import { loggerMock } from '@kbn/logging-mocks'; import { savedObjectsRepositoryMock } from '@kbn/core/server/mocks'; import { backfillClientMock } from '../../../backfill_client/backfill_client.mock'; import { calculateGapStateFromAllBackfills } from './calculate_gaps_state'; import { Gap } from '../gap'; import { adHocRunStatus } from '../../../../common/constants'; import { actionsClientMock } from '@kbn/actions-plugin/server/mocks'; +import { toScheduledItem } from './utils'; + +jest.mock('./utils', () => { + const actual = jest.requireActual('./utils'); + return { + ...actual, + toScheduledItem: jest.fn().mockImplementation((item) => { + if (item.shouldError) { + throw new Error('error in toScheduledItem'); + } + return actual.toScheduledItem(item); + }), + }; +}); + +const toScheduledItemMock = toScheduledItem as jest.Mock; + describe('calculateGapStateFromAllBackfills', () => { const mockSavedObjectsRepository = savedObjectsRepositoryMock.create(); const mockBackfillClient = backfillClientMock.create(); const actionsClient = actionsClientMock.create(); + const mockedLogger = loggerMock.create(); beforeEach(() => { - jest.resetAllMocks(); + jest.clearAllMocks(); mockBackfillClient.findOverlappingBackfills.mockResolvedValue([]); }); @@ -35,6 +53,7 @@ describe('calculateGapStateFromAllBackfills', () => { ruleId: 'test-rule-id', backfillClient: mockBackfillClient, actionsClient, + logger: mockedLogger, }); expect(mockBackfillClient.findOverlappingBackfills).toHaveBeenCalledWith({ @@ -68,6 +87,7 @@ describe('calculateGapStateFromAllBackfills', () => { ruleId: 'test-rule-id', backfillClient: mockBackfillClient, actionsClient, + logger: mockedLogger, }); expect(spy).toHaveBeenCalled(); @@ -105,6 +125,7 @@ describe('calculateGapStateFromAllBackfills', () => { ruleId: 'test-rule-id', backfillClient: mockBackfillClient, actionsClient, + logger: mockedLogger, }); expect(updatedGap.inProgressIntervals).toHaveLength(1); @@ -141,6 +162,59 @@ describe('calculateGapStateFromAllBackfills', () => { ruleId: 'test-rule-id', backfillClient: mockBackfillClient, actionsClient, + logger: mockedLogger, + }); + + expect(updatedGap.inProgressIntervals).toHaveLength(1); + expect(updatedGap.inProgressIntervals[0]).toEqual({ + gte: new Date('2024-01-01T00:00:00.000Z'), + lte: new Date('2024-01-01T00:15:00.000Z'), + }); + }); + + it('should log an error and recover when converting to scheduled item throws an error', async () => { + const testGap = new Gap({ + range: { + gte: '2024-01-01T00:00:00.000Z', + lte: '2024-01-01T01:00:00.000Z', + }, + }); + + mockBackfillClient.findOverlappingBackfills.mockResolvedValueOnce([ + { error: 'Some error' }, + { + schedule: [ + { + runAt: '2024-01-01T00:15:00.000Z', + interval: '15m', + status: adHocRunStatus.RUNNING, + }, + { + runAt: '2024-01-01T00:15:00.000Z', + interval: '15m', + status: adHocRunStatus.RUNNING, + shouldError: true, + }, + ], + }, + ]); + + const actualToScheduledItem = jest.requireActual('./utils').toScheduledItem; + toScheduledItemMock.mockImplementationOnce((item) => { + if (item.shouldError) { + throw new Error('error in toScheduledItem'); + } + + return actualToScheduledItem(item); + }); + + const updatedGap = await calculateGapStateFromAllBackfills({ + gap: testGap, + savedObjectsRepository: mockSavedObjectsRepository, + ruleId: 'test-rule-id', + backfillClient: mockBackfillClient, + actionsClient, + logger: mockedLogger, }); expect(updatedGap.inProgressIntervals).toHaveLength(1); @@ -148,5 +222,8 @@ describe('calculateGapStateFromAllBackfills', () => { gte: new Date('2024-01-01T00:00:00.000Z'), lte: new Date('2024-01-01T00:15:00.000Z'), }); + expect(mockedLogger.error).toHaveBeenCalledWith( + 'Error processing a scheduled item while updating gaps: error in toScheduledItem' + ); }); }); diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.ts index 64960ee8539b8..93d535ca64b0d 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/calculate_gaps_state.ts @@ -5,11 +5,12 @@ * 2.0. */ -import type { ISavedObjectsRepository } from '@kbn/core/server'; +import type { ISavedObjectsRepository, Logger } from '@kbn/core/server'; import type { ActionsClient } from '@kbn/actions-plugin/server'; import type { Gap } from '../gap'; import { updateGapFromSchedule } from './update_gap_from_schedule'; import type { BackfillClient } from '../../../backfill_client/backfill_client'; +import type { ScheduledItem } from './utils'; import { toScheduledItem } from './utils'; /** @@ -21,12 +22,14 @@ export const calculateGapStateFromAllBackfills = async ({ ruleId, backfillClient, actionsClient, + logger, }: { gap: Gap; savedObjectsRepository: ISavedObjectsRepository; ruleId: string; backfillClient: BackfillClient; actionsClient: ActionsClient; + logger: Logger; }): Promise => { const transformedBackfills = await backfillClient.findOverlappingBackfills({ ruleId, @@ -41,7 +44,16 @@ export const calculateGapStateFromAllBackfills = async ({ if ('error' in backfill) { continue; } - const scheduledItems = backfill?.schedule.map(toScheduledItem) ?? []; + const scheduledItems = (backfill?.schedule ?? []) + .map((backfillSchedule) => { + try { + return toScheduledItem(backfillSchedule); + } catch (error) { + logger.error(`Error processing a scheduled item while updating gaps: ${error.message}`); + return undefined; + } + }) + .filter((scheduledItem): scheduledItem is ScheduledItem => scheduledItem !== undefined); gap = updateGapFromSchedule({ gap, scheduledItems, diff --git a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts index 63395cbdbdf4c..f3910ae5d84f6 100644 --- a/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts +++ b/x-pack/platform/plugins/shared/alerting/server/lib/rule_gaps/update/update_gaps.ts @@ -48,6 +48,7 @@ export const prepareGapForUpdate = async ( scheduledItems, savedObjectsRepository, shouldRefetchAllBackfills, + logger, backfillClient, actionsClient, ruleId, @@ -55,12 +56,13 @@ export const prepareGapForUpdate = async ( scheduledItems: ScheduledItem[]; savedObjectsRepository: ISavedObjectsRepository; shouldRefetchAllBackfills?: boolean; + logger: Logger; backfillClient: BackfillClient; actionsClient: ActionsClient; ruleId: string; } ) => { - const hasFailedBackfillTask = scheduledItems?.some( + const hasFailedBackfillTask = scheduledItems.some( (scheduleItem) => scheduleItem.status === adHocRunStatus.ERROR || scheduleItem.status === adHocRunStatus.TIMEOUT ); @@ -77,13 +79,14 @@ export const prepareGapForUpdate = async ( ); } - if (hasFailedBackfillTask || !scheduledItems || shouldRefetchAllBackfills) { + if (hasFailedBackfillTask || scheduledItems.length === 0 || shouldRefetchAllBackfills) { await calculateGapStateFromAllBackfills({ gap, savedObjectsRepository, ruleId, backfillClient, actionsClient, + logger, }); } @@ -136,6 +139,7 @@ const updateGapBatch = async ( scheduledItems: scheduled, savedObjectsRepository, shouldRefetchAllBackfills, + logger, backfillClient, actionsClient, ruleId, From 4a2140152d3e866d6e2cee063e4f93f2107e1a4e Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Thu, 12 Jun 2025 15:09:43 +0200 Subject: [PATCH 12/14] add bulkGet to read operations --- .../feature_privilege_builder/alerting.test.ts | 15 +++++++++++++++ .../feature_privilege_builder/alerting.ts | 1 + .../src/privileges/privileges.test.ts | 2 ++ 3 files changed, 18 insertions(+) diff --git a/x-pack/platform/packages/private/security/authorization_core/src/privileges/feature_privilege_builder/alerting.test.ts b/x-pack/platform/packages/private/security/authorization_core/src/privileges/feature_privilege_builder/alerting.test.ts index db53a2181057c..0ee0f43631396 100644 --- a/x-pack/platform/packages/private/security/authorization_core/src/privileges/feature_privilege_builder/alerting.test.ts +++ b/x-pack/platform/packages/private/security/authorization_core/src/privileges/feature_privilege_builder/alerting.test.ts @@ -82,6 +82,7 @@ describe(`feature_privilege_builder`, () => { expect(alertingFeaturePrivileges.getActions(privilege, feature)).toMatchInlineSnapshot(` Array [ "alerting:alert-type/my-consumer/rule/get", + "alerting:alert-type/my-consumer/rule/bulkGet", "alerting:alert-type/my-consumer/rule/getRuleState", "alerting:alert-type/my-consumer/rule/getAlertSummary", "alerting:alert-type/my-consumer/rule/getExecutionLog", @@ -170,6 +171,7 @@ describe(`feature_privilege_builder`, () => { expect(alertingFeaturePrivileges.getActions(privilege, feature)).toMatchInlineSnapshot(` Array [ "alerting:alert-type/my-consumer/rule/get", + "alerting:alert-type/my-consumer/rule/bulkGet", "alerting:alert-type/my-consumer/rule/getRuleState", "alerting:alert-type/my-consumer/rule/getAlertSummary", "alerting:alert-type/my-consumer/rule/getExecutionLog", @@ -220,6 +222,7 @@ describe(`feature_privilege_builder`, () => { expect(alertingFeaturePrivileges.getActions(privilege, feature)).toMatchInlineSnapshot(` Array [ "alerting:alert-type/my-consumer/rule/get", + "alerting:alert-type/my-consumer/rule/bulkGet", "alerting:alert-type/my-consumer/rule/getRuleState", "alerting:alert-type/my-consumer/rule/getAlertSummary", "alerting:alert-type/my-consumer/rule/getExecutionLog", @@ -329,6 +332,7 @@ describe(`feature_privilege_builder`, () => { expect(alertingFeaturePrivileges.getActions(privilege, feature)).toMatchInlineSnapshot(` Array [ "alerting:alert-type/my-consumer/rule/get", + "alerting:alert-type/my-consumer/rule/bulkGet", "alerting:alert-type/my-consumer/rule/getRuleState", "alerting:alert-type/my-consumer/rule/getAlertSummary", "alerting:alert-type/my-consumer/rule/getExecutionLog", @@ -399,6 +403,7 @@ describe(`feature_privilege_builder`, () => { expect(alertingFeaturePrivileges.getActions(privilege, feature)).toMatchInlineSnapshot(` Array [ "alerting:alert-type/my-consumer/rule/get", + "alerting:alert-type/my-consumer/rule/bulkGet", "alerting:alert-type/my-consumer/rule/getRuleState", "alerting:alert-type/my-consumer/rule/getAlertSummary", "alerting:alert-type/my-consumer/rule/getExecutionLog", @@ -429,6 +434,7 @@ describe(`feature_privilege_builder`, () => { "alerting:alert-type/my-consumer/rule/deleteBackfill", "alerting:alert-type/my-consumer/rule/fillGaps", "alerting:readonly-alert-type/my-consumer/rule/get", + "alerting:readonly-alert-type/my-consumer/rule/bulkGet", "alerting:readonly-alert-type/my-consumer/rule/getRuleState", "alerting:readonly-alert-type/my-consumer/rule/getAlertSummary", "alerting:readonly-alert-type/my-consumer/rule/getExecutionLog", @@ -524,6 +530,7 @@ describe(`feature_privilege_builder`, () => { expect(alertingFeaturePrivileges.getActions(privilege, feature)).toMatchInlineSnapshot(` Array [ "alerting:alert-type/my-consumer/rule/get", + "alerting:alert-type/my-consumer/rule/bulkGet", "alerting:alert-type/my-consumer/rule/getRuleState", "alerting:alert-type/my-consumer/rule/getAlertSummary", "alerting:alert-type/my-consumer/rule/getExecutionLog", @@ -554,6 +561,7 @@ describe(`feature_privilege_builder`, () => { "alerting:alert-type/my-consumer/rule/deleteBackfill", "alerting:alert-type/my-consumer/rule/fillGaps", "alerting:readonly-alert-type/my-consumer/rule/get", + "alerting:readonly-alert-type/my-consumer/rule/bulkGet", "alerting:readonly-alert-type/my-consumer/rule/getRuleState", "alerting:readonly-alert-type/my-consumer/rule/getAlertSummary", "alerting:readonly-alert-type/my-consumer/rule/getExecutionLog", @@ -643,6 +651,7 @@ describe(`feature_privilege_builder`, () => { expect(alertingFeaturePrivileges.getActions(privilege, feature)).toMatchInlineSnapshot(` Array [ "alerting:alert-type-1/my-consumer-1/rule/get", + "alerting:alert-type-1/my-consumer-1/rule/bulkGet", "alerting:alert-type-1/my-consumer-1/rule/getRuleState", "alerting:alert-type-1/my-consumer-1/rule/getAlertSummary", "alerting:alert-type-1/my-consumer-1/rule/getExecutionLog", @@ -673,6 +682,7 @@ describe(`feature_privilege_builder`, () => { "alerting:alert-type-1/my-consumer-1/rule/deleteBackfill", "alerting:alert-type-1/my-consumer-1/rule/fillGaps", "alerting:alert-type-1/my-consumer-2/rule/get", + "alerting:alert-type-1/my-consumer-2/rule/bulkGet", "alerting:alert-type-1/my-consumer-2/rule/getRuleState", "alerting:alert-type-1/my-consumer-2/rule/getAlertSummary", "alerting:alert-type-1/my-consumer-2/rule/getExecutionLog", @@ -703,6 +713,7 @@ describe(`feature_privilege_builder`, () => { "alerting:alert-type-1/my-consumer-2/rule/deleteBackfill", "alerting:alert-type-1/my-consumer-2/rule/fillGaps", "alerting:alert-type-2/my-consumer-3/rule/get", + "alerting:alert-type-2/my-consumer-3/rule/bulkGet", "alerting:alert-type-2/my-consumer-3/rule/getRuleState", "alerting:alert-type-2/my-consumer-3/rule/getAlertSummary", "alerting:alert-type-2/my-consumer-3/rule/getExecutionLog", @@ -733,6 +744,7 @@ describe(`feature_privilege_builder`, () => { "alerting:alert-type-2/my-consumer-3/rule/deleteBackfill", "alerting:alert-type-2/my-consumer-3/rule/fillGaps", "alerting:readonly-alert-type-1/my-read-consumer-1/rule/get", + "alerting:readonly-alert-type-1/my-read-consumer-1/rule/bulkGet", "alerting:readonly-alert-type-1/my-read-consumer-1/rule/getRuleState", "alerting:readonly-alert-type-1/my-read-consumer-1/rule/getAlertSummary", "alerting:readonly-alert-type-1/my-read-consumer-1/rule/getExecutionLog", @@ -743,6 +755,7 @@ describe(`feature_privilege_builder`, () => { "alerting:readonly-alert-type-1/my-read-consumer-1/rule/findBackfill", "alerting:readonly-alert-type-1/my-read-consumer-1/rule/findGaps", "alerting:readonly-alert-type-1/my-read-consumer-2/rule/get", + "alerting:readonly-alert-type-1/my-read-consumer-2/rule/bulkGet", "alerting:readonly-alert-type-1/my-read-consumer-2/rule/getRuleState", "alerting:readonly-alert-type-1/my-read-consumer-2/rule/getAlertSummary", "alerting:readonly-alert-type-1/my-read-consumer-2/rule/getExecutionLog", @@ -753,6 +766,7 @@ describe(`feature_privilege_builder`, () => { "alerting:readonly-alert-type-1/my-read-consumer-2/rule/findBackfill", "alerting:readonly-alert-type-1/my-read-consumer-2/rule/findGaps", "alerting:readonly-alert-type-2/my-read-consumer-3/rule/get", + "alerting:readonly-alert-type-2/my-read-consumer-3/rule/bulkGet", "alerting:readonly-alert-type-2/my-read-consumer-3/rule/getRuleState", "alerting:readonly-alert-type-2/my-read-consumer-3/rule/getAlertSummary", "alerting:readonly-alert-type-2/my-read-consumer-3/rule/getExecutionLog", @@ -763,6 +777,7 @@ describe(`feature_privilege_builder`, () => { "alerting:readonly-alert-type-2/my-read-consumer-3/rule/findBackfill", "alerting:readonly-alert-type-2/my-read-consumer-3/rule/findGaps", "alerting:readonly-alert-type-2/my-read-consumer-4/rule/get", + "alerting:readonly-alert-type-2/my-read-consumer-4/rule/bulkGet", "alerting:readonly-alert-type-2/my-read-consumer-4/rule/getRuleState", "alerting:readonly-alert-type-2/my-read-consumer-4/rule/getAlertSummary", "alerting:readonly-alert-type-2/my-read-consumer-4/rule/getExecutionLog", diff --git a/x-pack/platform/packages/private/security/authorization_core/src/privileges/feature_privilege_builder/alerting.ts b/x-pack/platform/packages/private/security/authorization_core/src/privileges/feature_privilege_builder/alerting.ts index cc94f400ddab1..507ede1e8699f 100644 --- a/x-pack/platform/packages/private/security/authorization_core/src/privileges/feature_privilege_builder/alerting.ts +++ b/x-pack/platform/packages/private/security/authorization_core/src/privileges/feature_privilege_builder/alerting.ts @@ -20,6 +20,7 @@ enum AlertingEntity { const readOperations: Record = { rule: [ 'get', + 'bulkGet', 'getRuleState', 'getAlertSummary', 'getExecutionLog', diff --git a/x-pack/platform/packages/private/security/authorization_core/src/privileges/privileges.test.ts b/x-pack/platform/packages/private/security/authorization_core/src/privileges/privileges.test.ts index 29db7c588ed62..3018251a1480e 100644 --- a/x-pack/platform/packages/private/security/authorization_core/src/privileges/privileges.test.ts +++ b/x-pack/platform/packages/private/security/authorization_core/src/privileges/privileges.test.ts @@ -565,6 +565,7 @@ describe('features', () => { const alertingOperations = [ ...[ 'get', + 'bulkGet', 'getRuleState', 'getAlertSummary', 'getExecutionLog', @@ -741,6 +742,7 @@ describe('features', () => { const alertingOperations = [ ...[ 'get', + 'bulkGet', 'getRuleState', 'getAlertSummary', 'getExecutionLog', From 49c4925435c87f51077516613be8aa0021154765 Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Thu, 12 Jun 2025 17:37:27 +0200 Subject: [PATCH 13/14] fix api integration tests --- .../platform_security/authorization.ts | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/x-pack/test_serverless/api_integration/test_suites/security/platform_security/authorization.ts b/x-pack/test_serverless/api_integration/test_suites/security/platform_security/authorization.ts index 69fd0d9d54fb5..e1b0073dd6f77 100644 --- a/x-pack/test_serverless/api_integration/test_suites/security/platform_security/authorization.ts +++ b/x-pack/test_serverless/api_integration/test_suites/security/platform_security/authorization.ts @@ -505,6 +505,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:siemV2/showEndpointExceptions", "ui:siemV2/crudEndpointExceptions", "alerting:siem.notifications/siem/rule/get", + "alerting:siem.notifications/siem/rule/bulkGet", "alerting:siem.notifications/siem/rule/getRuleState", "alerting:siem.notifications/siem/rule/getAlertSummary", "alerting:siem.notifications/siem/rule/getExecutionLog", @@ -535,6 +536,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.notifications/siem/rule/deleteBackfill", "alerting:siem.notifications/siem/rule/fillGaps", "alerting:siem.esqlRule/siem/rule/get", + "alerting:siem.esqlRule/siem/rule/bulkGet", "alerting:siem.esqlRule/siem/rule/getRuleState", "alerting:siem.esqlRule/siem/rule/getAlertSummary", "alerting:siem.esqlRule/siem/rule/getExecutionLog", @@ -565,6 +567,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.esqlRule/siem/rule/deleteBackfill", "alerting:siem.esqlRule/siem/rule/fillGaps", "alerting:siem.eqlRule/siem/rule/get", + "alerting:siem.eqlRule/siem/rule/bulkGet", "alerting:siem.eqlRule/siem/rule/getRuleState", "alerting:siem.eqlRule/siem/rule/getAlertSummary", "alerting:siem.eqlRule/siem/rule/getExecutionLog", @@ -595,6 +598,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.eqlRule/siem/rule/deleteBackfill", "alerting:siem.eqlRule/siem/rule/fillGaps", "alerting:siem.indicatorRule/siem/rule/get", + "alerting:siem.indicatorRule/siem/rule/bulkGet", "alerting:siem.indicatorRule/siem/rule/getRuleState", "alerting:siem.indicatorRule/siem/rule/getAlertSummary", "alerting:siem.indicatorRule/siem/rule/getExecutionLog", @@ -625,6 +629,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.indicatorRule/siem/rule/deleteBackfill", "alerting:siem.indicatorRule/siem/rule/fillGaps", "alerting:siem.mlRule/siem/rule/get", + "alerting:siem.mlRule/siem/rule/bulkGet", "alerting:siem.mlRule/siem/rule/getRuleState", "alerting:siem.mlRule/siem/rule/getAlertSummary", "alerting:siem.mlRule/siem/rule/getExecutionLog", @@ -655,6 +660,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.mlRule/siem/rule/deleteBackfill", "alerting:siem.mlRule/siem/rule/fillGaps", "alerting:siem.queryRule/siem/rule/get", + "alerting:siem.queryRule/siem/rule/bulkGet", "alerting:siem.queryRule/siem/rule/getRuleState", "alerting:siem.queryRule/siem/rule/getAlertSummary", "alerting:siem.queryRule/siem/rule/getExecutionLog", @@ -685,6 +691,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.queryRule/siem/rule/deleteBackfill", "alerting:siem.queryRule/siem/rule/fillGaps", "alerting:siem.savedQueryRule/siem/rule/get", + "alerting:siem.savedQueryRule/siem/rule/bulkGet", "alerting:siem.savedQueryRule/siem/rule/getRuleState", "alerting:siem.savedQueryRule/siem/rule/getAlertSummary", "alerting:siem.savedQueryRule/siem/rule/getExecutionLog", @@ -715,6 +722,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.savedQueryRule/siem/rule/deleteBackfill", "alerting:siem.savedQueryRule/siem/rule/fillGaps", "alerting:siem.thresholdRule/siem/rule/get", + "alerting:siem.thresholdRule/siem/rule/bulkGet", "alerting:siem.thresholdRule/siem/rule/getRuleState", "alerting:siem.thresholdRule/siem/rule/getAlertSummary", "alerting:siem.thresholdRule/siem/rule/getExecutionLog", @@ -745,6 +753,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.thresholdRule/siem/rule/deleteBackfill", "alerting:siem.thresholdRule/siem/rule/fillGaps", "alerting:siem.newTermsRule/siem/rule/get", + "alerting:siem.newTermsRule/siem/rule/bulkGet", "alerting:siem.newTermsRule/siem/rule/getRuleState", "alerting:siem.newTermsRule/siem/rule/getAlertSummary", "alerting:siem.newTermsRule/siem/rule/getExecutionLog", @@ -1371,6 +1380,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:siemV2/investigation-guide-interactions", "ui:siemV2/threat-intelligence", "alerting:siem.notifications/siem/rule/get", + "alerting:siem.notifications/siem/rule/bulkGet", "alerting:siem.notifications/siem/rule/getRuleState", "alerting:siem.notifications/siem/rule/getAlertSummary", "alerting:siem.notifications/siem/rule/getExecutionLog", @@ -1401,6 +1411,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.notifications/siem/rule/deleteBackfill", "alerting:siem.notifications/siem/rule/fillGaps", "alerting:siem.esqlRule/siem/rule/get", + "alerting:siem.esqlRule/siem/rule/bulkGet", "alerting:siem.esqlRule/siem/rule/getRuleState", "alerting:siem.esqlRule/siem/rule/getAlertSummary", "alerting:siem.esqlRule/siem/rule/getExecutionLog", @@ -1431,6 +1442,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.esqlRule/siem/rule/deleteBackfill", "alerting:siem.esqlRule/siem/rule/fillGaps", "alerting:siem.eqlRule/siem/rule/get", + "alerting:siem.eqlRule/siem/rule/bulkGet", "alerting:siem.eqlRule/siem/rule/getRuleState", "alerting:siem.eqlRule/siem/rule/getAlertSummary", "alerting:siem.eqlRule/siem/rule/getExecutionLog", @@ -1461,6 +1473,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.eqlRule/siem/rule/deleteBackfill", "alerting:siem.eqlRule/siem/rule/fillGaps", "alerting:siem.indicatorRule/siem/rule/get", + "alerting:siem.indicatorRule/siem/rule/bulkGet", "alerting:siem.indicatorRule/siem/rule/getRuleState", "alerting:siem.indicatorRule/siem/rule/getAlertSummary", "alerting:siem.indicatorRule/siem/rule/getExecutionLog", @@ -1491,6 +1504,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.indicatorRule/siem/rule/deleteBackfill", "alerting:siem.indicatorRule/siem/rule/fillGaps", "alerting:siem.mlRule/siem/rule/get", + "alerting:siem.mlRule/siem/rule/bulkGet", "alerting:siem.mlRule/siem/rule/getRuleState", "alerting:siem.mlRule/siem/rule/getAlertSummary", "alerting:siem.mlRule/siem/rule/getExecutionLog", @@ -1521,6 +1535,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.mlRule/siem/rule/deleteBackfill", "alerting:siem.mlRule/siem/rule/fillGaps", "alerting:siem.queryRule/siem/rule/get", + "alerting:siem.queryRule/siem/rule/bulkGet", "alerting:siem.queryRule/siem/rule/getRuleState", "alerting:siem.queryRule/siem/rule/getAlertSummary", "alerting:siem.queryRule/siem/rule/getExecutionLog", @@ -1551,6 +1566,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.queryRule/siem/rule/deleteBackfill", "alerting:siem.queryRule/siem/rule/fillGaps", "alerting:siem.savedQueryRule/siem/rule/get", + "alerting:siem.savedQueryRule/siem/rule/bulkGet", "alerting:siem.savedQueryRule/siem/rule/getRuleState", "alerting:siem.savedQueryRule/siem/rule/getAlertSummary", "alerting:siem.savedQueryRule/siem/rule/getExecutionLog", @@ -1581,6 +1597,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.savedQueryRule/siem/rule/deleteBackfill", "alerting:siem.savedQueryRule/siem/rule/fillGaps", "alerting:siem.thresholdRule/siem/rule/get", + "alerting:siem.thresholdRule/siem/rule/bulkGet", "alerting:siem.thresholdRule/siem/rule/getRuleState", "alerting:siem.thresholdRule/siem/rule/getAlertSummary", "alerting:siem.thresholdRule/siem/rule/getExecutionLog", @@ -1611,6 +1628,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.thresholdRule/siem/rule/deleteBackfill", "alerting:siem.thresholdRule/siem/rule/fillGaps", "alerting:siem.newTermsRule/siem/rule/get", + "alerting:siem.newTermsRule/siem/rule/bulkGet", "alerting:siem.newTermsRule/siem/rule/getRuleState", "alerting:siem.newTermsRule/siem/rule/getAlertSummary", "alerting:siem.newTermsRule/siem/rule/getExecutionLog", @@ -1960,6 +1978,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:siemV2/investigation-guide-interactions", "ui:siemV2/threat-intelligence", "alerting:siem.notifications/siem/rule/get", + "alerting:siem.notifications/siem/rule/bulkGet", "alerting:siem.notifications/siem/rule/getRuleState", "alerting:siem.notifications/siem/rule/getAlertSummary", "alerting:siem.notifications/siem/rule/getExecutionLog", @@ -1970,6 +1989,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.notifications/siem/rule/findBackfill", "alerting:siem.notifications/siem/rule/findGaps", "alerting:siem.esqlRule/siem/rule/get", + "alerting:siem.esqlRule/siem/rule/bulkGet", "alerting:siem.esqlRule/siem/rule/getRuleState", "alerting:siem.esqlRule/siem/rule/getAlertSummary", "alerting:siem.esqlRule/siem/rule/getExecutionLog", @@ -1980,6 +2000,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.esqlRule/siem/rule/findBackfill", "alerting:siem.esqlRule/siem/rule/findGaps", "alerting:siem.eqlRule/siem/rule/get", + "alerting:siem.eqlRule/siem/rule/bulkGet", "alerting:siem.eqlRule/siem/rule/getRuleState", "alerting:siem.eqlRule/siem/rule/getAlertSummary", "alerting:siem.eqlRule/siem/rule/getExecutionLog", @@ -1990,6 +2011,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.eqlRule/siem/rule/findBackfill", "alerting:siem.eqlRule/siem/rule/findGaps", "alerting:siem.indicatorRule/siem/rule/get", + "alerting:siem.indicatorRule/siem/rule/bulkGet", "alerting:siem.indicatorRule/siem/rule/getRuleState", "alerting:siem.indicatorRule/siem/rule/getAlertSummary", "alerting:siem.indicatorRule/siem/rule/getExecutionLog", @@ -2000,6 +2022,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.indicatorRule/siem/rule/findBackfill", "alerting:siem.indicatorRule/siem/rule/findGaps", "alerting:siem.mlRule/siem/rule/get", + "alerting:siem.mlRule/siem/rule/bulkGet", "alerting:siem.mlRule/siem/rule/getRuleState", "alerting:siem.mlRule/siem/rule/getAlertSummary", "alerting:siem.mlRule/siem/rule/getExecutionLog", @@ -2010,6 +2033,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.mlRule/siem/rule/findBackfill", "alerting:siem.mlRule/siem/rule/findGaps", "alerting:siem.queryRule/siem/rule/get", + "alerting:siem.queryRule/siem/rule/bulkGet", "alerting:siem.queryRule/siem/rule/getRuleState", "alerting:siem.queryRule/siem/rule/getAlertSummary", "alerting:siem.queryRule/siem/rule/getExecutionLog", @@ -2020,6 +2044,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.queryRule/siem/rule/findBackfill", "alerting:siem.queryRule/siem/rule/findGaps", "alerting:siem.savedQueryRule/siem/rule/get", + "alerting:siem.savedQueryRule/siem/rule/bulkGet", "alerting:siem.savedQueryRule/siem/rule/getRuleState", "alerting:siem.savedQueryRule/siem/rule/getAlertSummary", "alerting:siem.savedQueryRule/siem/rule/getExecutionLog", @@ -2030,6 +2055,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.savedQueryRule/siem/rule/findBackfill", "alerting:siem.savedQueryRule/siem/rule/findGaps", "alerting:siem.thresholdRule/siem/rule/get", + "alerting:siem.thresholdRule/siem/rule/bulkGet", "alerting:siem.thresholdRule/siem/rule/getRuleState", "alerting:siem.thresholdRule/siem/rule/getAlertSummary", "alerting:siem.thresholdRule/siem/rule/getExecutionLog", @@ -2040,6 +2066,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.thresholdRule/siem/rule/findBackfill", "alerting:siem.thresholdRule/siem/rule/findGaps", "alerting:siem.newTermsRule/siem/rule/get", + "alerting:siem.newTermsRule/siem/rule/bulkGet", "alerting:siem.newTermsRule/siem/rule/getRuleState", "alerting:siem.newTermsRule/siem/rule/getAlertSummary", "alerting:siem.newTermsRule/siem/rule/getExecutionLog", @@ -2340,6 +2367,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:siemV2/threat-intelligence", "ui:siemV2/showEndpointExceptions", "alerting:siem.notifications/siem/rule/get", + "alerting:siem.notifications/siem/rule/bulkGet", "alerting:siem.notifications/siem/rule/getRuleState", "alerting:siem.notifications/siem/rule/getAlertSummary", "alerting:siem.notifications/siem/rule/getExecutionLog", @@ -2350,6 +2378,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.notifications/siem/rule/findBackfill", "alerting:siem.notifications/siem/rule/findGaps", "alerting:siem.esqlRule/siem/rule/get", + "alerting:siem.esqlRule/siem/rule/bulkGet", "alerting:siem.esqlRule/siem/rule/getRuleState", "alerting:siem.esqlRule/siem/rule/getAlertSummary", "alerting:siem.esqlRule/siem/rule/getExecutionLog", @@ -2360,6 +2389,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.esqlRule/siem/rule/findBackfill", "alerting:siem.esqlRule/siem/rule/findGaps", "alerting:siem.eqlRule/siem/rule/get", + "alerting:siem.eqlRule/siem/rule/bulkGet", "alerting:siem.eqlRule/siem/rule/getRuleState", "alerting:siem.eqlRule/siem/rule/getAlertSummary", "alerting:siem.eqlRule/siem/rule/getExecutionLog", @@ -2370,6 +2400,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.eqlRule/siem/rule/findBackfill", "alerting:siem.eqlRule/siem/rule/findGaps", "alerting:siem.indicatorRule/siem/rule/get", + "alerting:siem.indicatorRule/siem/rule/bulkGet", "alerting:siem.indicatorRule/siem/rule/getRuleState", "alerting:siem.indicatorRule/siem/rule/getAlertSummary", "alerting:siem.indicatorRule/siem/rule/getExecutionLog", @@ -2380,6 +2411,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.indicatorRule/siem/rule/findBackfill", "alerting:siem.indicatorRule/siem/rule/findGaps", "alerting:siem.mlRule/siem/rule/get", + "alerting:siem.mlRule/siem/rule/bulkGet", "alerting:siem.mlRule/siem/rule/getRuleState", "alerting:siem.mlRule/siem/rule/getAlertSummary", "alerting:siem.mlRule/siem/rule/getExecutionLog", @@ -2390,6 +2422,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.mlRule/siem/rule/findBackfill", "alerting:siem.mlRule/siem/rule/findGaps", "alerting:siem.queryRule/siem/rule/get", + "alerting:siem.queryRule/siem/rule/bulkGet", "alerting:siem.queryRule/siem/rule/getRuleState", "alerting:siem.queryRule/siem/rule/getAlertSummary", "alerting:siem.queryRule/siem/rule/getExecutionLog", @@ -2400,6 +2433,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.queryRule/siem/rule/findBackfill", "alerting:siem.queryRule/siem/rule/findGaps", "alerting:siem.savedQueryRule/siem/rule/get", + "alerting:siem.savedQueryRule/siem/rule/bulkGet", "alerting:siem.savedQueryRule/siem/rule/getRuleState", "alerting:siem.savedQueryRule/siem/rule/getAlertSummary", "alerting:siem.savedQueryRule/siem/rule/getExecutionLog", @@ -2410,6 +2444,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.savedQueryRule/siem/rule/findBackfill", "alerting:siem.savedQueryRule/siem/rule/findGaps", "alerting:siem.thresholdRule/siem/rule/get", + "alerting:siem.thresholdRule/siem/rule/bulkGet", "alerting:siem.thresholdRule/siem/rule/getRuleState", "alerting:siem.thresholdRule/siem/rule/getAlertSummary", "alerting:siem.thresholdRule/siem/rule/getExecutionLog", @@ -2420,6 +2455,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:siem.thresholdRule/siem/rule/findBackfill", "alerting:siem.thresholdRule/siem/rule/findGaps", "alerting:siem.newTermsRule/siem/rule/get", + "alerting:siem.newTermsRule/siem/rule/bulkGet", "alerting:siem.newTermsRule/siem/rule/getRuleState", "alerting:siem.newTermsRule/siem/rule/getAlertSummary", "alerting:siem.newTermsRule/siem/rule/getExecutionLog", From 96ca64e81ac115df88bf319c8c427518ae0dcfca Mon Sep 17 00:00:00 2001 From: Edgar Santos Date: Thu, 12 Jun 2025 19:35:59 +0200 Subject: [PATCH 14/14] fix integration tests --- .../platform_security/authorization.ts | 944 ++++++++++++++++++ 1 file changed, 944 insertions(+) diff --git a/x-pack/test_serverless/api_integration/test_suites/observability/platform_security/authorization.ts b/x-pack/test_serverless/api_integration/test_suites/observability/platform_security/authorization.ts index 7f53719b63f4b..98ab300d980fe 100644 --- a/x-pack/test_serverless/api_integration/test_suites/observability/platform_security/authorization.ts +++ b/x-pack/test_serverless/api_integration/test_suites/observability/platform_security/authorization.ts @@ -112,6 +112,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:apm/alerting:save", "ui:apm/settings:save", "alerting:apm.error_rate/apm/rule/get", + "alerting:apm.error_rate/apm/rule/bulkGet", "alerting:apm.error_rate/apm/rule/getRuleState", "alerting:apm.error_rate/apm/rule/getAlertSummary", "alerting:apm.error_rate/apm/rule/getExecutionLog", @@ -142,6 +143,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/apm/rule/deleteBackfill", "alerting:apm.error_rate/apm/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -172,6 +174,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/apm/rule/get", + "alerting:apm.transaction_error_rate/apm/rule/bulkGet", "alerting:apm.transaction_error_rate/apm/rule/getRuleState", "alerting:apm.transaction_error_rate/apm/rule/getAlertSummary", "alerting:apm.transaction_error_rate/apm/rule/getExecutionLog", @@ -202,6 +205,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/apm/rule/deleteBackfill", "alerting:apm.transaction_error_rate/apm/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -232,6 +236,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/apm/rule/get", + "alerting:apm.transaction_duration/apm/rule/bulkGet", "alerting:apm.transaction_duration/apm/rule/getRuleState", "alerting:apm.transaction_duration/apm/rule/getAlertSummary", "alerting:apm.transaction_duration/apm/rule/getExecutionLog", @@ -262,6 +267,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/apm/rule/deleteBackfill", "alerting:apm.transaction_duration/apm/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -292,6 +298,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/apm/rule/get", + "alerting:apm.anomaly/apm/rule/bulkGet", "alerting:apm.anomaly/apm/rule/getRuleState", "alerting:apm.anomaly/apm/rule/getAlertSummary", "alerting:apm.anomaly/apm/rule/getExecutionLog", @@ -322,6 +329,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/apm/rule/deleteBackfill", "alerting:apm.anomaly/apm/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -428,6 +436,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:logs/configureSource", "ui:logs/save", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -458,6 +467,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/deleteBackfill", "alerting:logs.alert.document.count/logs/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -488,6 +498,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -518,6 +529,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/deleteBackfill", "alerting:.es-query/logs/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -548,6 +560,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -578,6 +591,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/logs/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -608,6 +622,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -638,6 +653,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/logs/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -713,6 +729,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -743,6 +760,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -773,6 +791,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -803,6 +822,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -833,6 +853,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -863,6 +884,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -893,6 +915,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -923,6 +946,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -953,6 +977,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -983,6 +1008,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -1013,6 +1039,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -1043,6 +1070,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -1073,6 +1101,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -1103,6 +1132,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -1133,6 +1163,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -1163,6 +1194,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -1193,6 +1225,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -1223,6 +1256,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -1253,6 +1287,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -1283,6 +1318,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -1313,6 +1349,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -1343,6 +1380,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -1373,6 +1411,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -1403,6 +1442,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/deleteBackfill", "alerting:slo.rules.burnRate/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -1433,6 +1473,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -1463,6 +1504,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -1683,6 +1725,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:apm/alerting:show", "ui:apm/alerting:save", "alerting:apm.error_rate/apm/rule/get", + "alerting:apm.error_rate/apm/rule/bulkGet", "alerting:apm.error_rate/apm/rule/getRuleState", "alerting:apm.error_rate/apm/rule/getAlertSummary", "alerting:apm.error_rate/apm/rule/getExecutionLog", @@ -1713,6 +1756,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/apm/rule/deleteBackfill", "alerting:apm.error_rate/apm/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -1743,6 +1787,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/apm/rule/get", + "alerting:apm.transaction_error_rate/apm/rule/bulkGet", "alerting:apm.transaction_error_rate/apm/rule/getRuleState", "alerting:apm.transaction_error_rate/apm/rule/getAlertSummary", "alerting:apm.transaction_error_rate/apm/rule/getExecutionLog", @@ -1773,6 +1818,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/apm/rule/deleteBackfill", "alerting:apm.transaction_error_rate/apm/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -1803,6 +1849,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/apm/rule/get", + "alerting:apm.transaction_duration/apm/rule/bulkGet", "alerting:apm.transaction_duration/apm/rule/getRuleState", "alerting:apm.transaction_duration/apm/rule/getAlertSummary", "alerting:apm.transaction_duration/apm/rule/getExecutionLog", @@ -1833,6 +1880,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/apm/rule/deleteBackfill", "alerting:apm.transaction_duration/apm/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -1863,6 +1911,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/apm/rule/get", + "alerting:apm.anomaly/apm/rule/bulkGet", "alerting:apm.anomaly/apm/rule/getRuleState", "alerting:apm.anomaly/apm/rule/getAlertSummary", "alerting:apm.anomaly/apm/rule/getExecutionLog", @@ -1893,6 +1942,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/apm/rule/deleteBackfill", "alerting:apm.anomaly/apm/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -1999,6 +2049,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:logs/configureSource", "ui:logs/save", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -2029,6 +2080,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/deleteBackfill", "alerting:logs.alert.document.count/logs/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -2059,6 +2111,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -2089,6 +2142,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/deleteBackfill", "alerting:.es-query/logs/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -2119,6 +2173,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -2149,6 +2204,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/logs/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -2179,6 +2235,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -2209,6 +2266,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/logs/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -2284,6 +2342,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -2314,6 +2373,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -2344,6 +2404,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -2374,6 +2435,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -2404,6 +2466,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -2434,6 +2497,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -2464,6 +2528,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -2494,6 +2559,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -2524,6 +2590,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -2554,6 +2621,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -2584,6 +2652,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -2614,6 +2683,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -2644,6 +2714,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -2674,6 +2745,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -2704,6 +2776,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -2734,6 +2807,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -2764,6 +2838,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -2794,6 +2869,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -2824,6 +2900,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -2854,6 +2931,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -2884,6 +2962,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -2914,6 +2993,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -2944,6 +3024,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -2974,6 +3055,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/deleteBackfill", "alerting:slo.rules.burnRate/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -3004,6 +3086,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -3034,6 +3117,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -3244,6 +3328,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:apm/show", "ui:apm/alerting:show", "alerting:apm.error_rate/apm/rule/get", + "alerting:apm.error_rate/apm/rule/bulkGet", "alerting:apm.error_rate/apm/rule/getRuleState", "alerting:apm.error_rate/apm/rule/getAlertSummary", "alerting:apm.error_rate/apm/rule/getExecutionLog", @@ -3254,6 +3339,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/apm/rule/findBackfill", "alerting:apm.error_rate/apm/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -3264,6 +3350,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/apm/rule/get", + "alerting:apm.transaction_error_rate/apm/rule/bulkGet", "alerting:apm.transaction_error_rate/apm/rule/getRuleState", "alerting:apm.transaction_error_rate/apm/rule/getAlertSummary", "alerting:apm.transaction_error_rate/apm/rule/getExecutionLog", @@ -3274,6 +3361,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/apm/rule/findBackfill", "alerting:apm.transaction_error_rate/apm/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -3284,6 +3372,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/apm/rule/get", + "alerting:apm.transaction_duration/apm/rule/bulkGet", "alerting:apm.transaction_duration/apm/rule/getRuleState", "alerting:apm.transaction_duration/apm/rule/getAlertSummary", "alerting:apm.transaction_duration/apm/rule/getExecutionLog", @@ -3294,6 +3383,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/apm/rule/findBackfill", "alerting:apm.transaction_duration/apm/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -3304,6 +3394,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/apm/rule/get", + "alerting:apm.anomaly/apm/rule/bulkGet", "alerting:apm.anomaly/apm/rule/getRuleState", "alerting:apm.anomaly/apm/rule/getAlertSummary", "alerting:apm.anomaly/apm/rule/getExecutionLog", @@ -3314,6 +3405,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/apm/rule/findBackfill", "alerting:apm.anomaly/apm/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -3376,6 +3468,7 @@ export default function ({ getService }: FtrProviderContext) { "saved_object:infrastructure-monitoring-log-view/close_point_in_time", "ui:logs/show", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -3386,6 +3479,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/findBackfill", "alerting:logs.alert.document.count/logs/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -3396,6 +3490,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -3406,6 +3501,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/findBackfill", "alerting:.es-query/logs/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -3416,6 +3512,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -3426,6 +3523,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/findBackfill", "alerting:observability.rules.custom_threshold/logs/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -3436,6 +3534,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -3446,6 +3545,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/logs/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -3492,6 +3592,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -3502,6 +3603,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -3512,6 +3614,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -3522,6 +3625,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -3532,6 +3636,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -3542,6 +3647,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -3552,6 +3658,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -3562,6 +3669,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -3572,6 +3680,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -3582,6 +3691,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -3592,6 +3702,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -3602,6 +3713,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -3612,6 +3724,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -3622,6 +3735,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -3632,6 +3746,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -3642,6 +3757,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -3652,6 +3768,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -3662,6 +3779,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -3672,6 +3790,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -3682,6 +3801,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -3692,6 +3812,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -3702,6 +3823,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -3712,6 +3834,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -3722,6 +3845,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/findBackfill", "alerting:slo.rules.burnRate/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -3732,6 +3856,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -3742,6 +3867,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -3906,6 +4032,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:apm/show", "ui:apm/alerting:show", "alerting:apm.error_rate/apm/rule/get", + "alerting:apm.error_rate/apm/rule/bulkGet", "alerting:apm.error_rate/apm/rule/getRuleState", "alerting:apm.error_rate/apm/rule/getAlertSummary", "alerting:apm.error_rate/apm/rule/getExecutionLog", @@ -3916,6 +4043,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/apm/rule/findBackfill", "alerting:apm.error_rate/apm/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -3926,6 +4054,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/apm/rule/get", + "alerting:apm.transaction_error_rate/apm/rule/bulkGet", "alerting:apm.transaction_error_rate/apm/rule/getRuleState", "alerting:apm.transaction_error_rate/apm/rule/getAlertSummary", "alerting:apm.transaction_error_rate/apm/rule/getExecutionLog", @@ -3936,6 +4065,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/apm/rule/findBackfill", "alerting:apm.transaction_error_rate/apm/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -3946,6 +4076,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/apm/rule/get", + "alerting:apm.transaction_duration/apm/rule/bulkGet", "alerting:apm.transaction_duration/apm/rule/getRuleState", "alerting:apm.transaction_duration/apm/rule/getAlertSummary", "alerting:apm.transaction_duration/apm/rule/getExecutionLog", @@ -3956,6 +4087,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/apm/rule/findBackfill", "alerting:apm.transaction_duration/apm/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -3966,6 +4098,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/apm/rule/get", + "alerting:apm.anomaly/apm/rule/bulkGet", "alerting:apm.anomaly/apm/rule/getRuleState", "alerting:apm.anomaly/apm/rule/getAlertSummary", "alerting:apm.anomaly/apm/rule/getExecutionLog", @@ -3976,6 +4109,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/apm/rule/findBackfill", "alerting:apm.anomaly/apm/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -4038,6 +4172,7 @@ export default function ({ getService }: FtrProviderContext) { "saved_object:infrastructure-monitoring-log-view/close_point_in_time", "ui:logs/show", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -4048,6 +4183,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/findBackfill", "alerting:logs.alert.document.count/logs/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -4058,6 +4194,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -4068,6 +4205,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/findBackfill", "alerting:.es-query/logs/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -4078,6 +4216,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -4088,6 +4227,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/findBackfill", "alerting:observability.rules.custom_threshold/logs/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -4098,6 +4238,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -4108,6 +4249,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/logs/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -4154,6 +4296,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -4164,6 +4307,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -4174,6 +4318,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -4184,6 +4329,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -4194,6 +4340,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -4204,6 +4351,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -4214,6 +4362,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -4224,6 +4373,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -4234,6 +4384,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -4244,6 +4395,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -4254,6 +4406,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -4264,6 +4417,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -4274,6 +4428,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -4284,6 +4439,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -4294,6 +4450,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -4304,6 +4461,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -4314,6 +4472,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -4324,6 +4483,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -4334,6 +4494,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -4344,6 +4505,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -4354,6 +4516,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -4364,6 +4527,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -4374,6 +4538,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -4384,6 +4549,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/findBackfill", "alerting:slo.rules.burnRate/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -4394,6 +4560,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -4404,6 +4571,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -5866,6 +6034,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -5896,6 +6065,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -5926,6 +6096,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -5956,6 +6127,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -5986,6 +6158,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -6016,6 +6189,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -6046,6 +6220,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -6076,6 +6251,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -6106,6 +6282,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/deleteBackfill", "alerting:apm.anomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -6136,6 +6313,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -6166,6 +6344,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -6196,6 +6375,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -6226,6 +6406,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -6256,6 +6437,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -6286,6 +6468,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -6316,6 +6499,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -6346,6 +6530,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -6376,6 +6561,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -6406,6 +6592,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -6436,6 +6623,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -6466,6 +6654,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -6496,6 +6685,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -6526,6 +6716,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -6556,6 +6747,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -6586,6 +6778,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -6616,6 +6809,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -6646,6 +6840,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -6676,6 +6871,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -6706,6 +6902,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/deleteBackfill", "alerting:slo.rules.burnRate/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -6736,6 +6933,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -6766,6 +6964,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -6796,6 +6995,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -6826,6 +7026,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -6856,6 +7057,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -7156,6 +7358,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -7186,6 +7389,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -7216,6 +7420,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -7246,6 +7451,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -7276,6 +7482,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -7306,6 +7513,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -7336,6 +7544,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -7366,6 +7575,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -7396,6 +7606,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/deleteBackfill", "alerting:apm.anomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -7426,6 +7637,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -7456,6 +7668,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -7486,6 +7699,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -7516,6 +7730,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -7546,6 +7761,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -7576,6 +7792,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -7606,6 +7823,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -7636,6 +7854,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -7666,6 +7885,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -7696,6 +7916,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -7726,6 +7947,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -7756,6 +7978,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -7786,6 +8009,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -7816,6 +8040,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -7846,6 +8071,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -7876,6 +8102,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -7906,6 +8133,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -7936,6 +8164,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -7966,6 +8195,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -7996,6 +8226,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/deleteBackfill", "alerting:slo.rules.burnRate/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -8026,6 +8257,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -8056,6 +8288,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -8086,6 +8319,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -8116,6 +8350,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -8146,6 +8381,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -8410,6 +8646,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -8420,6 +8657,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -8430,6 +8668,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -8440,6 +8679,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -8450,6 +8690,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -8460,6 +8701,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -8470,6 +8712,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -8480,6 +8723,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -8490,6 +8734,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/findBackfill", "alerting:apm.anomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -8500,6 +8745,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -8510,6 +8756,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -8520,6 +8767,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -8530,6 +8778,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -8540,6 +8789,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -8550,6 +8800,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -8560,6 +8811,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -8570,6 +8822,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -8580,6 +8833,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -8590,6 +8844,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -8600,6 +8855,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -8610,6 +8866,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -8620,6 +8877,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -8630,6 +8888,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -8640,6 +8899,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -8650,6 +8910,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -8660,6 +8921,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -8670,6 +8932,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -8680,6 +8943,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -8690,6 +8954,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/findBackfill", "alerting:slo.rules.burnRate/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -8700,6 +8965,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -8710,6 +8976,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -8720,6 +8987,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -8730,6 +8998,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -8740,6 +9009,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -8956,6 +9226,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -8966,6 +9237,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -8976,6 +9248,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -8986,6 +9259,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -8996,6 +9270,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -9006,6 +9281,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -9016,6 +9292,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -9026,6 +9303,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -9036,6 +9314,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/findBackfill", "alerting:apm.anomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -9046,6 +9325,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -9056,6 +9336,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -9066,6 +9347,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -9076,6 +9358,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -9086,6 +9369,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -9096,6 +9380,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -9106,6 +9391,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -9116,6 +9402,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -9126,6 +9413,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -9136,6 +9424,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -9146,6 +9435,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -9156,6 +9446,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -9166,6 +9457,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -9176,6 +9468,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -9186,6 +9479,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -9196,6 +9490,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -9206,6 +9501,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -9216,6 +9512,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -9226,6 +9523,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -9236,6 +9534,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/findBackfill", "alerting:slo.rules.burnRate/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -9246,6 +9545,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -9256,6 +9556,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -9266,6 +9567,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -9276,6 +9578,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -9286,6 +9589,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -9570,6 +9874,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -9600,6 +9905,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -9630,6 +9936,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -9660,6 +9967,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -9690,6 +9998,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -9720,6 +10029,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -9750,6 +10060,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -9780,6 +10091,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -9810,6 +10122,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/deleteBackfill", "alerting:apm.anomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -9840,6 +10153,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -9870,6 +10184,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -9900,6 +10215,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -9930,6 +10246,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -9960,6 +10277,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -9990,6 +10308,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -10020,6 +10339,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -10050,6 +10370,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -10080,6 +10401,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -10110,6 +10432,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -10140,6 +10463,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -10170,6 +10494,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -10200,6 +10525,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -10230,6 +10556,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -10260,6 +10587,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -10290,6 +10618,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -10320,6 +10649,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -10350,6 +10680,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -10380,6 +10711,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -10410,6 +10742,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/deleteBackfill", "alerting:slo.rules.burnRate/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -10440,6 +10773,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -10470,6 +10804,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -10500,6 +10835,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -10530,6 +10866,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -10560,6 +10897,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -10837,6 +11175,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -10867,6 +11206,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -10897,6 +11237,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -10927,6 +11268,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -10957,6 +11299,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -10987,6 +11330,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -11017,6 +11361,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -11047,6 +11392,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -11077,6 +11423,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/deleteBackfill", "alerting:apm.anomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -11107,6 +11454,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -11137,6 +11485,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -11167,6 +11516,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -11197,6 +11547,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -11227,6 +11578,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -11257,6 +11609,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -11287,6 +11640,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -11317,6 +11671,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -11347,6 +11702,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -11377,6 +11733,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -11407,6 +11764,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -11437,6 +11795,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -11467,6 +11826,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -11497,6 +11857,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -11527,6 +11888,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -11557,6 +11919,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -11587,6 +11950,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -11617,6 +11981,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -11647,6 +12012,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -11677,6 +12043,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/deleteBackfill", "alerting:slo.rules.burnRate/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -11707,6 +12074,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -11737,6 +12105,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -11767,6 +12136,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -11797,6 +12167,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -11827,6 +12198,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -12081,6 +12453,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -12091,6 +12464,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -12101,6 +12475,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -12111,6 +12486,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -12121,6 +12497,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -12131,6 +12508,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -12141,6 +12519,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -12151,6 +12530,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -12161,6 +12541,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/findBackfill", "alerting:apm.anomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -12171,6 +12552,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -12181,6 +12563,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -12191,6 +12574,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -12201,6 +12585,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -12211,6 +12596,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -12221,6 +12607,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -12231,6 +12618,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -12241,6 +12629,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -12251,6 +12640,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -12261,6 +12651,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -12271,6 +12662,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -12281,6 +12673,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -12291,6 +12684,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -12301,6 +12695,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -12311,6 +12706,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -12321,6 +12717,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -12331,6 +12728,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -12341,6 +12739,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -12351,6 +12750,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -12361,6 +12761,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/findBackfill", "alerting:slo.rules.burnRate/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -12371,6 +12772,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -12381,6 +12783,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -12391,6 +12794,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -12401,6 +12805,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -12411,6 +12816,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -12619,6 +13025,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -12629,6 +13036,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -12639,6 +13047,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -12649,6 +13058,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -12659,6 +13069,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -12669,6 +13080,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -12679,6 +13091,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -12689,6 +13102,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -12699,6 +13113,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/findBackfill", "alerting:apm.anomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -12709,6 +13124,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -12719,6 +13135,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -12729,6 +13146,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -12739,6 +13157,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -12749,6 +13168,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -12759,6 +13179,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -12769,6 +13190,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -12779,6 +13201,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -12789,6 +13212,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -12799,6 +13223,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -12809,6 +13234,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -12819,6 +13245,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -12829,6 +13256,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -12839,6 +13267,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -12849,6 +13278,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -12859,6 +13289,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -12869,6 +13300,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -12879,6 +13311,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -12889,6 +13322,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -12899,6 +13333,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/findBackfill", "alerting:slo.rules.burnRate/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -12909,6 +13344,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -12919,6 +13355,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -12929,6 +13366,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -12939,6 +13377,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -12949,6 +13388,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -13806,6 +14246,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:logs/configureSource", "ui:logs/save", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -13836,6 +14277,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/deleteBackfill", "alerting:logs.alert.document.count/logs/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -13866,6 +14308,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -13896,6 +14339,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/deleteBackfill", "alerting:.es-query/logs/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -13926,6 +14370,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -13956,6 +14401,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/logs/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -13986,6 +14432,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -14016,6 +14463,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/logs/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -14317,6 +14765,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:logs/configureSource", "ui:logs/save", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -14347,6 +14796,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/deleteBackfill", "alerting:logs.alert.document.count/logs/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -14377,6 +14827,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -14407,6 +14858,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/deleteBackfill", "alerting:.es-query/logs/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -14437,6 +14889,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -14467,6 +14920,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/logs/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -14497,6 +14951,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -14527,6 +14982,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/logs/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -14719,6 +15175,7 @@ export default function ({ getService }: FtrProviderContext) { "saved_object:infrastructure-monitoring-log-view/close_point_in_time", "ui:logs/show", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -14729,6 +15186,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/findBackfill", "alerting:logs.alert.document.count/logs/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -14739,6 +15197,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -14749,6 +15208,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/findBackfill", "alerting:.es-query/logs/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -14759,6 +15219,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -14769,6 +15230,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/findBackfill", "alerting:observability.rules.custom_threshold/logs/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -14779,6 +15241,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -14789,6 +15252,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/logs/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -14959,6 +15423,7 @@ export default function ({ getService }: FtrProviderContext) { "saved_object:infrastructure-monitoring-log-view/close_point_in_time", "ui:logs/show", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -14969,6 +15434,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/findBackfill", "alerting:logs.alert.document.count/logs/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -14979,6 +15445,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -14989,6 +15456,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/findBackfill", "alerting:.es-query/logs/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -14999,6 +15467,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -15009,6 +15478,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/findBackfill", "alerting:observability.rules.custom_threshold/logs/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -15019,6 +15489,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -15029,6 +15500,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/logs/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -15372,6 +15844,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:infrastructure/configureSource", "ui:infrastructure/save", "alerting:metrics.alert.threshold/infrastructure/rule/get", + "alerting:metrics.alert.threshold/infrastructure/rule/bulkGet", "alerting:metrics.alert.threshold/infrastructure/rule/getRuleState", "alerting:metrics.alert.threshold/infrastructure/rule/getAlertSummary", "alerting:metrics.alert.threshold/infrastructure/rule/getExecutionLog", @@ -15402,6 +15875,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/infrastructure/rule/deleteBackfill", "alerting:metrics.alert.threshold/infrastructure/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -15432,6 +15906,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/get", + "alerting:metrics.alert.inventory.threshold/infrastructure/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getExecutionLog", @@ -15462,6 +15937,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/infrastructure/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -15492,6 +15968,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:.es-query/infrastructure/rule/get", + "alerting:.es-query/infrastructure/rule/bulkGet", "alerting:.es-query/infrastructure/rule/getRuleState", "alerting:.es-query/infrastructure/rule/getAlertSummary", "alerting:.es-query/infrastructure/rule/getExecutionLog", @@ -15522,6 +15999,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/infrastructure/rule/deleteBackfill", "alerting:.es-query/infrastructure/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -15552,6 +16030,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/infrastructure/rule/get", + "alerting:observability.rules.custom_threshold/infrastructure/rule/bulkGet", "alerting:observability.rules.custom_threshold/infrastructure/rule/getRuleState", "alerting:observability.rules.custom_threshold/infrastructure/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/infrastructure/rule/getExecutionLog", @@ -15582,6 +16061,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/infrastructure/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/infrastructure/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -15612,6 +16092,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getExecutionLog", @@ -15642,6 +16123,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -15743,6 +16225,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:logs/configureSource", "ui:logs/save", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -15773,6 +16256,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/deleteBackfill", "alerting:logs.alert.document.count/logs/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -15803,6 +16287,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -15833,6 +16318,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/deleteBackfill", "alerting:.es-query/logs/rule/fillGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -15863,6 +16349,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/logs/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -15923,6 +16410,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -15953,6 +16441,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -15983,6 +16472,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -16013,6 +16503,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -16043,6 +16534,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -16073,6 +16565,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -16103,6 +16596,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -16133,6 +16627,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -16163,6 +16658,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/deleteBackfill", "alerting:apm.anomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -16193,6 +16689,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -16223,6 +16720,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -16253,6 +16751,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -16283,6 +16782,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -16313,6 +16813,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -16343,6 +16844,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -16373,6 +16875,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -16403,6 +16906,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -16433,6 +16937,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -16463,6 +16968,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -16493,6 +16999,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -16523,6 +17030,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -16553,6 +17061,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -16583,6 +17092,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -16613,6 +17123,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -16643,6 +17154,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -16673,6 +17185,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/deleteBackfill", "alerting:slo.rules.burnRate/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -16703,6 +17216,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -16733,6 +17247,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -16986,6 +17501,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:infrastructure/configureSource", "ui:infrastructure/save", "alerting:metrics.alert.threshold/infrastructure/rule/get", + "alerting:metrics.alert.threshold/infrastructure/rule/bulkGet", "alerting:metrics.alert.threshold/infrastructure/rule/getRuleState", "alerting:metrics.alert.threshold/infrastructure/rule/getAlertSummary", "alerting:metrics.alert.threshold/infrastructure/rule/getExecutionLog", @@ -17016,6 +17532,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/infrastructure/rule/deleteBackfill", "alerting:metrics.alert.threshold/infrastructure/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -17046,6 +17563,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/get", + "alerting:metrics.alert.inventory.threshold/infrastructure/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getExecutionLog", @@ -17076,6 +17594,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/infrastructure/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -17106,6 +17625,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:.es-query/infrastructure/rule/get", + "alerting:.es-query/infrastructure/rule/bulkGet", "alerting:.es-query/infrastructure/rule/getRuleState", "alerting:.es-query/infrastructure/rule/getAlertSummary", "alerting:.es-query/infrastructure/rule/getExecutionLog", @@ -17136,6 +17656,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/infrastructure/rule/deleteBackfill", "alerting:.es-query/infrastructure/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -17166,6 +17687,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/infrastructure/rule/get", + "alerting:observability.rules.custom_threshold/infrastructure/rule/bulkGet", "alerting:observability.rules.custom_threshold/infrastructure/rule/getRuleState", "alerting:observability.rules.custom_threshold/infrastructure/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/infrastructure/rule/getExecutionLog", @@ -17196,6 +17718,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/infrastructure/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/infrastructure/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -17226,6 +17749,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getExecutionLog", @@ -17256,6 +17780,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -17357,6 +17882,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:logs/configureSource", "ui:logs/save", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -17387,6 +17913,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/deleteBackfill", "alerting:logs.alert.document.count/logs/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -17417,6 +17944,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -17447,6 +17975,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/deleteBackfill", "alerting:.es-query/logs/rule/fillGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -17477,6 +18006,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/logs/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -17537,6 +18067,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -17567,6 +18098,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -17597,6 +18129,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -17627,6 +18160,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -17657,6 +18191,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -17687,6 +18222,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -17717,6 +18253,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -17747,6 +18284,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -17777,6 +18315,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/deleteBackfill", "alerting:apm.anomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -17807,6 +18346,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -17837,6 +18377,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -17867,6 +18408,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -17897,6 +18439,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -17927,6 +18470,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -17957,6 +18501,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -17987,6 +18532,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -18017,6 +18563,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -18047,6 +18594,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -18077,6 +18625,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -18107,6 +18656,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -18137,6 +18687,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -18167,6 +18718,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -18197,6 +18749,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -18227,6 +18780,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -18257,6 +18811,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -18287,6 +18842,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/deleteBackfill", "alerting:slo.rules.burnRate/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -18317,6 +18873,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -18347,6 +18904,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -18577,6 +19135,7 @@ export default function ({ getService }: FtrProviderContext) { "saved_object:cloud/close_point_in_time", "ui:infrastructure/show", "alerting:metrics.alert.threshold/infrastructure/rule/get", + "alerting:metrics.alert.threshold/infrastructure/rule/bulkGet", "alerting:metrics.alert.threshold/infrastructure/rule/getRuleState", "alerting:metrics.alert.threshold/infrastructure/rule/getAlertSummary", "alerting:metrics.alert.threshold/infrastructure/rule/getExecutionLog", @@ -18587,6 +19146,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/infrastructure/rule/findBackfill", "alerting:metrics.alert.threshold/infrastructure/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -18597,6 +19157,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/get", + "alerting:metrics.alert.inventory.threshold/infrastructure/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getExecutionLog", @@ -18607,6 +19168,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/infrastructure/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -18617,6 +19179,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:.es-query/infrastructure/rule/get", + "alerting:.es-query/infrastructure/rule/bulkGet", "alerting:.es-query/infrastructure/rule/getRuleState", "alerting:.es-query/infrastructure/rule/getAlertSummary", "alerting:.es-query/infrastructure/rule/getExecutionLog", @@ -18627,6 +19190,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/infrastructure/rule/findBackfill", "alerting:.es-query/infrastructure/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -18637,6 +19201,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/infrastructure/rule/get", + "alerting:observability.rules.custom_threshold/infrastructure/rule/bulkGet", "alerting:observability.rules.custom_threshold/infrastructure/rule/getRuleState", "alerting:observability.rules.custom_threshold/infrastructure/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/infrastructure/rule/getExecutionLog", @@ -18647,6 +19212,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/infrastructure/rule/findBackfill", "alerting:observability.rules.custom_threshold/infrastructure/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -18657,6 +19223,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getExecutionLog", @@ -18667,6 +19234,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -18729,6 +19297,7 @@ export default function ({ getService }: FtrProviderContext) { "saved_object:infrastructure-monitoring-log-view/close_point_in_time", "ui:logs/show", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -18739,6 +19308,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/findBackfill", "alerting:logs.alert.document.count/logs/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -18749,6 +19319,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -18759,6 +19330,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/findBackfill", "alerting:.es-query/logs/rule/findGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -18769,6 +19341,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/findBackfill", "alerting:observability.rules.custom_threshold/logs/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -18803,6 +19376,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -18813,6 +19387,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -18823,6 +19398,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -18833,6 +19409,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -18843,6 +19420,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -18853,6 +19431,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -18863,6 +19442,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -18873,6 +19453,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -18883,6 +19464,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/findBackfill", "alerting:apm.anomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -18893,6 +19475,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -18903,6 +19486,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -18913,6 +19497,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -18923,6 +19508,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -18933,6 +19519,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -18943,6 +19530,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -18953,6 +19541,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -18963,6 +19552,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -18973,6 +19563,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -18983,6 +19574,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -18993,6 +19585,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -19003,6 +19596,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -19013,6 +19607,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -19023,6 +19618,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -19033,6 +19629,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -19043,6 +19640,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -19053,6 +19651,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/findBackfill", "alerting:slo.rules.burnRate/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -19063,6 +19662,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -19073,6 +19673,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -19255,6 +19856,7 @@ export default function ({ getService }: FtrProviderContext) { "saved_object:cloud/close_point_in_time", "ui:infrastructure/show", "alerting:metrics.alert.threshold/infrastructure/rule/get", + "alerting:metrics.alert.threshold/infrastructure/rule/bulkGet", "alerting:metrics.alert.threshold/infrastructure/rule/getRuleState", "alerting:metrics.alert.threshold/infrastructure/rule/getAlertSummary", "alerting:metrics.alert.threshold/infrastructure/rule/getExecutionLog", @@ -19265,6 +19867,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/infrastructure/rule/findBackfill", "alerting:metrics.alert.threshold/infrastructure/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -19275,6 +19878,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/get", + "alerting:metrics.alert.inventory.threshold/infrastructure/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/getExecutionLog", @@ -19285,6 +19889,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/infrastructure/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/infrastructure/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -19295,6 +19900,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:.es-query/infrastructure/rule/get", + "alerting:.es-query/infrastructure/rule/bulkGet", "alerting:.es-query/infrastructure/rule/getRuleState", "alerting:.es-query/infrastructure/rule/getAlertSummary", "alerting:.es-query/infrastructure/rule/getExecutionLog", @@ -19305,6 +19911,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/infrastructure/rule/findBackfill", "alerting:.es-query/infrastructure/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -19315,6 +19922,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/infrastructure/rule/get", + "alerting:observability.rules.custom_threshold/infrastructure/rule/bulkGet", "alerting:observability.rules.custom_threshold/infrastructure/rule/getRuleState", "alerting:observability.rules.custom_threshold/infrastructure/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/infrastructure/rule/getExecutionLog", @@ -19325,6 +19933,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/infrastructure/rule/findBackfill", "alerting:observability.rules.custom_threshold/infrastructure/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -19335,6 +19944,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/getExecutionLog", @@ -19345,6 +19955,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/infrastructure/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -19407,6 +20018,7 @@ export default function ({ getService }: FtrProviderContext) { "saved_object:infrastructure-monitoring-log-view/close_point_in_time", "ui:logs/show", "alerting:logs.alert.document.count/logs/rule/get", + "alerting:logs.alert.document.count/logs/rule/bulkGet", "alerting:logs.alert.document.count/logs/rule/getRuleState", "alerting:logs.alert.document.count/logs/rule/getAlertSummary", "alerting:logs.alert.document.count/logs/rule/getExecutionLog", @@ -19417,6 +20029,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/logs/rule/findBackfill", "alerting:logs.alert.document.count/logs/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -19427,6 +20040,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:.es-query/logs/rule/get", + "alerting:.es-query/logs/rule/bulkGet", "alerting:.es-query/logs/rule/getRuleState", "alerting:.es-query/logs/rule/getAlertSummary", "alerting:.es-query/logs/rule/getExecutionLog", @@ -19437,6 +20051,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/logs/rule/findBackfill", "alerting:.es-query/logs/rule/findGaps", "alerting:observability.rules.custom_threshold/logs/rule/get", + "alerting:observability.rules.custom_threshold/logs/rule/bulkGet", "alerting:observability.rules.custom_threshold/logs/rule/getRuleState", "alerting:observability.rules.custom_threshold/logs/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/logs/rule/getExecutionLog", @@ -19447,6 +20062,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/logs/rule/findBackfill", "alerting:observability.rules.custom_threshold/logs/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/logs/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/logs/rule/getExecutionLog", @@ -19481,6 +20097,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -19491,6 +20108,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -19501,6 +20119,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -19511,6 +20130,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -19521,6 +20141,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -19531,6 +20152,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -19541,6 +20163,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -19551,6 +20174,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -19561,6 +20185,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/findBackfill", "alerting:apm.anomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -19571,6 +20196,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -19581,6 +20207,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -19591,6 +20218,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -19601,6 +20229,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -19611,6 +20240,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -19621,6 +20251,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -19631,6 +20262,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -19641,6 +20273,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -19651,6 +20284,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -19661,6 +20295,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -19671,6 +20306,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -19681,6 +20317,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -19691,6 +20328,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -19701,6 +20339,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -19711,6 +20350,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -19721,6 +20361,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -19731,6 +20372,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/findBackfill", "alerting:slo.rules.burnRate/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -19741,6 +20383,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -19751,6 +20394,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -20108,6 +20752,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:slo/read", "ui:slo/write", "alerting:slo.rules.burnRate/slo/rule/get", + "alerting:slo.rules.burnRate/slo/rule/bulkGet", "alerting:slo.rules.burnRate/slo/rule/getRuleState", "alerting:slo.rules.burnRate/slo/rule/getAlertSummary", "alerting:slo.rules.burnRate/slo/rule/getExecutionLog", @@ -20138,6 +20783,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/slo/rule/deleteBackfill", "alerting:slo.rules.burnRate/slo/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -20182,6 +20828,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -20212,6 +20859,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -20242,6 +20890,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -20272,6 +20921,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -20302,6 +20952,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -20332,6 +20983,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -20362,6 +21014,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -20392,6 +21045,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -20422,6 +21076,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/deleteBackfill", "alerting:apm.anomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -20452,6 +21107,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -20482,6 +21138,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -20512,6 +21169,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -20542,6 +21200,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -20572,6 +21231,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -20602,6 +21262,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -20632,6 +21293,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -20662,6 +21324,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -20692,6 +21355,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -20722,6 +21386,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -20752,6 +21417,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -20782,6 +21448,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -20812,6 +21479,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -20842,6 +21510,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -20872,6 +21541,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -20902,6 +21572,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -20932,6 +21603,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -20962,6 +21634,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -20992,6 +21665,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -21022,6 +21696,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -21052,6 +21727,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -21082,6 +21758,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -21112,6 +21789,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -21142,6 +21820,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -21412,6 +22091,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:slo/read", "ui:slo/write", "alerting:slo.rules.burnRate/slo/rule/get", + "alerting:slo.rules.burnRate/slo/rule/bulkGet", "alerting:slo.rules.burnRate/slo/rule/getRuleState", "alerting:slo.rules.burnRate/slo/rule/getAlertSummary", "alerting:slo.rules.burnRate/slo/rule/getExecutionLog", @@ -21442,6 +22122,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/slo/rule/deleteBackfill", "alerting:slo.rules.burnRate/slo/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -21486,6 +22167,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -21516,6 +22198,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -21546,6 +22229,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -21576,6 +22260,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -21606,6 +22291,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -21636,6 +22322,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -21666,6 +22353,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -21696,6 +22384,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -21726,6 +22415,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/deleteBackfill", "alerting:apm.anomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -21756,6 +22446,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -21786,6 +22477,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -21816,6 +22508,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -21846,6 +22539,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -21876,6 +22570,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -21906,6 +22601,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -21936,6 +22632,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -21966,6 +22663,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -21996,6 +22694,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -22026,6 +22725,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -22056,6 +22756,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -22086,6 +22787,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -22116,6 +22818,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -22146,6 +22849,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -22176,6 +22880,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -22206,6 +22911,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -22236,6 +22942,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -22266,6 +22973,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -22296,6 +23004,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -22326,6 +23035,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -22356,6 +23066,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -22386,6 +23097,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -22416,6 +23128,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -22446,6 +23159,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -22693,6 +23407,7 @@ export default function ({ getService }: FtrProviderContext) { "saved_object:cloud/close_point_in_time", "ui:slo/read", "alerting:slo.rules.burnRate/slo/rule/get", + "alerting:slo.rules.burnRate/slo/rule/bulkGet", "alerting:slo.rules.burnRate/slo/rule/getRuleState", "alerting:slo.rules.burnRate/slo/rule/getAlertSummary", "alerting:slo.rules.burnRate/slo/rule/getExecutionLog", @@ -22703,6 +23418,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/slo/rule/findBackfill", "alerting:slo.rules.burnRate/slo/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -22724,6 +23440,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -22734,6 +23451,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -22744,6 +23462,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -22754,6 +23473,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -22764,6 +23484,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -22774,6 +23495,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -22784,6 +23506,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -22794,6 +23517,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -22804,6 +23528,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/findBackfill", "alerting:apm.anomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -22814,6 +23539,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -22824,6 +23550,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -22834,6 +23561,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -22844,6 +23572,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -22854,6 +23583,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -22864,6 +23594,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -22874,6 +23605,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -22884,6 +23616,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -22894,6 +23627,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -22904,6 +23638,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -22914,6 +23649,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -22924,6 +23660,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -22934,6 +23671,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -22944,6 +23682,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -22954,6 +23693,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -22964,6 +23704,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -22974,6 +23715,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -22984,6 +23726,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -22994,6 +23737,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -23004,6 +23748,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -23014,6 +23759,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -23024,6 +23770,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -23034,6 +23781,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -23044,6 +23792,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -23238,6 +23987,7 @@ export default function ({ getService }: FtrProviderContext) { "saved_object:cloud/close_point_in_time", "ui:slo/read", "alerting:slo.rules.burnRate/slo/rule/get", + "alerting:slo.rules.burnRate/slo/rule/bulkGet", "alerting:slo.rules.burnRate/slo/rule/getRuleState", "alerting:slo.rules.burnRate/slo/rule/getAlertSummary", "alerting:slo.rules.burnRate/slo/rule/getExecutionLog", @@ -23248,6 +23998,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/slo/rule/findBackfill", "alerting:slo.rules.burnRate/slo/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -23269,6 +24020,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -23279,6 +24031,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -23289,6 +24042,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -23299,6 +24053,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -23309,6 +24064,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -23319,6 +24075,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -23329,6 +24086,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -23339,6 +24097,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -23349,6 +24108,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/findBackfill", "alerting:apm.anomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -23359,6 +24119,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -23369,6 +24130,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -23379,6 +24141,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -23389,6 +24152,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/alerts/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -23399,6 +24163,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -23409,6 +24174,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -23419,6 +24185,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -23429,6 +24196,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -23439,6 +24207,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -23449,6 +24218,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -23459,6 +24229,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -23469,6 +24240,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -23479,6 +24251,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -23489,6 +24262,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -23499,6 +24273,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -23509,6 +24284,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -23519,6 +24295,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -23529,6 +24306,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -23539,6 +24317,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -23549,6 +24328,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -23559,6 +24339,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -23569,6 +24350,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -23579,6 +24361,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -23589,6 +24372,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -23876,6 +24660,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:uptime/elasticManagedLocationsEnabled", "ui:uptime/canManagePrivateLocations", "alerting:xpack.uptime.alerts.tls/uptime/rule/get", + "alerting:xpack.uptime.alerts.tls/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/uptime/rule/getExecutionLog", @@ -23906,6 +24691,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/uptime/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/uptime/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -23936,6 +24722,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getExecutionLog", @@ -23966,6 +24753,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -23996,6 +24784,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getExecutionLog", @@ -24026,6 +24815,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -24056,6 +24846,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getExecutionLog", @@ -24086,6 +24877,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -24116,6 +24908,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getExecutionLog", @@ -24146,6 +24939,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -24176,6 +24970,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/uptime/rule/get", + "alerting:xpack.synthetics.alerts.tls/uptime/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getExecutionLog", @@ -24206,6 +25001,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/uptime/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/uptime/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -24301,6 +25097,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -24331,6 +25128,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -24361,6 +25159,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -24391,6 +25190,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -24421,6 +25221,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -24451,6 +25252,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -24481,6 +25283,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -24511,6 +25314,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -24541,6 +25345,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/deleteBackfill", "alerting:apm.anomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -24571,6 +25376,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -24601,6 +25407,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -24631,6 +25438,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -24661,6 +25469,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -24691,6 +25500,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -24721,6 +25531,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -24751,6 +25562,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -24781,6 +25593,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -24811,6 +25624,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -24841,6 +25655,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -24871,6 +25686,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -24901,6 +25717,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -24931,6 +25748,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -24961,6 +25779,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/deleteBackfill", "alerting:slo.rules.burnRate/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -24991,6 +25810,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -25021,6 +25841,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -25051,6 +25872,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -25081,6 +25903,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -25111,6 +25934,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -25440,6 +26264,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:uptime/show", "ui:uptime/alerting:save", "alerting:xpack.uptime.alerts.tls/uptime/rule/get", + "alerting:xpack.uptime.alerts.tls/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/uptime/rule/getExecutionLog", @@ -25470,6 +26295,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/uptime/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/uptime/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -25500,6 +26326,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getExecutionLog", @@ -25530,6 +26357,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -25560,6 +26388,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getExecutionLog", @@ -25590,6 +26419,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -25620,6 +26450,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getExecutionLog", @@ -25650,6 +26481,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -25680,6 +26512,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getExecutionLog", @@ -25710,6 +26543,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -25740,6 +26574,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/uptime/rule/get", + "alerting:xpack.synthetics.alerts.tls/uptime/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getExecutionLog", @@ -25770,6 +26605,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/uptime/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/uptime/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -25865,6 +26701,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:observability/read", "ui:observability/write", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -25895,6 +26732,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/deleteBackfill", "alerting:apm.error_rate/observability/rule/fillGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -25925,6 +26763,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/deleteBackfill", "alerting:apm.error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -25955,6 +26794,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/deleteBackfill", "alerting:apm.transaction_error_rate/observability/rule/fillGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -25985,6 +26825,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/deleteBackfill", "alerting:apm.transaction_error_rate/alerts/rule/fillGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -26015,6 +26856,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/deleteBackfill", "alerting:apm.transaction_duration/observability/rule/fillGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -26045,6 +26887,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/deleteBackfill", "alerting:apm.transaction_duration/alerts/rule/fillGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -26075,6 +26918,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/deleteBackfill", "alerting:apm.anomaly/observability/rule/fillGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -26105,6 +26949,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/deleteBackfill", "alerting:apm.anomaly/alerts/rule/fillGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -26135,6 +26980,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -26165,6 +27011,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/fillGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -26195,6 +27042,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.threshold/observability/rule/fillGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -26225,6 +27073,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.threshold/alerts/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -26255,6 +27104,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/fillGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -26285,6 +27135,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/deleteBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/fillGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -26315,6 +27166,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -26345,6 +27197,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -26375,6 +27228,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/fillGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -26405,6 +27259,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/deleteBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/fillGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -26435,6 +27290,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/deleteBackfill", "alerting:logs.alert.document.count/observability/rule/fillGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -26465,6 +27321,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/deleteBackfill", "alerting:logs.alert.document.count/alerts/rule/fillGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -26495,6 +27352,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/deleteBackfill", "alerting:slo.rules.burnRate/observability/rule/fillGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -26525,6 +27383,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/deleteBackfill", "alerting:slo.rules.burnRate/alerts/rule/fillGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -26555,6 +27414,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/observability/rule/fillGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -26585,6 +27445,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/deleteBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/fillGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -26615,6 +27476,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/deleteBackfill", "alerting:.es-query/observability/rule/fillGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -26645,6 +27507,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/deleteBackfill", "alerting:.es-query/alerts/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -26675,6 +27538,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/deleteBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/fillGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -26926,6 +27790,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:uptime/show", "ui:uptime/alerting:save", "alerting:xpack.uptime.alerts.tls/uptime/rule/get", + "alerting:xpack.uptime.alerts.tls/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/uptime/rule/getExecutionLog", @@ -26936,6 +27801,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/uptime/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/uptime/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -26946,6 +27812,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getExecutionLog", @@ -26956,6 +27823,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -26966,6 +27834,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getExecutionLog", @@ -26976,6 +27845,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -26986,6 +27856,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getExecutionLog", @@ -26996,6 +27867,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -27006,6 +27878,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getExecutionLog", @@ -27016,6 +27889,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -27026,6 +27900,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/uptime/rule/get", + "alerting:xpack.synthetics.alerts.tls/uptime/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getExecutionLog", @@ -27036,6 +27911,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/uptime/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/uptime/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -27098,6 +27974,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -27108,6 +27985,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -27118,6 +27996,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -27128,6 +28007,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -27138,6 +28018,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -27148,6 +28029,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -27158,6 +28040,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -27168,6 +28051,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -27178,6 +28062,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/findBackfill", "alerting:apm.anomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -27188,6 +28073,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -27198,6 +28084,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -27208,6 +28095,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -27218,6 +28106,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -27228,6 +28117,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -27238,6 +28128,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -27248,6 +28139,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -27258,6 +28150,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -27268,6 +28161,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -27278,6 +28172,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -27288,6 +28183,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -27298,6 +28194,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -27308,6 +28205,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -27318,6 +28216,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/findBackfill", "alerting:slo.rules.burnRate/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -27328,6 +28227,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -27338,6 +28238,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -27348,6 +28249,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -27358,6 +28260,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -27368,6 +28271,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog", @@ -27571,6 +28475,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:uptime/show", "ui:uptime/alerting:save", "alerting:xpack.uptime.alerts.tls/uptime/rule/get", + "alerting:xpack.uptime.alerts.tls/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/uptime/rule/getExecutionLog", @@ -27581,6 +28486,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/uptime/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/uptime/rule/findGaps", "alerting:xpack.uptime.alerts.tls/alerts/rule/get", + "alerting:xpack.uptime.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/alerts/rule/getExecutionLog", @@ -27591,6 +28497,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/getExecutionLog", @@ -27601,6 +28508,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/uptime/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/getExecutionLog", @@ -27611,6 +28519,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/getExecutionLog", @@ -27621,6 +28530,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/uptime/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -27631,6 +28541,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/getExecutionLog", @@ -27641,6 +28552,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/uptime/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/getExecutionLog", @@ -27651,6 +28563,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/getExecutionLog", @@ -27661,6 +28574,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/uptime/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/getExecutionLog", @@ -27671,6 +28585,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/uptime/rule/get", + "alerting:xpack.synthetics.alerts.tls/uptime/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/uptime/rule/getExecutionLog", @@ -27681,6 +28596,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/uptime/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/uptime/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/alerts/rule/get", + "alerting:xpack.synthetics.alerts.tls/alerts/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/alerts/rule/getExecutionLog", @@ -27743,6 +28659,7 @@ export default function ({ getService }: FtrProviderContext) { "ui:navLinks/observability", "ui:observability/read", "alerting:apm.error_rate/observability/rule/get", + "alerting:apm.error_rate/observability/rule/bulkGet", "alerting:apm.error_rate/observability/rule/getRuleState", "alerting:apm.error_rate/observability/rule/getAlertSummary", "alerting:apm.error_rate/observability/rule/getExecutionLog", @@ -27753,6 +28670,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/observability/rule/findBackfill", "alerting:apm.error_rate/observability/rule/findGaps", "alerting:apm.error_rate/alerts/rule/get", + "alerting:apm.error_rate/alerts/rule/bulkGet", "alerting:apm.error_rate/alerts/rule/getRuleState", "alerting:apm.error_rate/alerts/rule/getAlertSummary", "alerting:apm.error_rate/alerts/rule/getExecutionLog", @@ -27763,6 +28681,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.error_rate/alerts/rule/findBackfill", "alerting:apm.error_rate/alerts/rule/findGaps", "alerting:apm.transaction_error_rate/observability/rule/get", + "alerting:apm.transaction_error_rate/observability/rule/bulkGet", "alerting:apm.transaction_error_rate/observability/rule/getRuleState", "alerting:apm.transaction_error_rate/observability/rule/getAlertSummary", "alerting:apm.transaction_error_rate/observability/rule/getExecutionLog", @@ -27773,6 +28692,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/observability/rule/findBackfill", "alerting:apm.transaction_error_rate/observability/rule/findGaps", "alerting:apm.transaction_error_rate/alerts/rule/get", + "alerting:apm.transaction_error_rate/alerts/rule/bulkGet", "alerting:apm.transaction_error_rate/alerts/rule/getRuleState", "alerting:apm.transaction_error_rate/alerts/rule/getAlertSummary", "alerting:apm.transaction_error_rate/alerts/rule/getExecutionLog", @@ -27783,6 +28703,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_error_rate/alerts/rule/findBackfill", "alerting:apm.transaction_error_rate/alerts/rule/findGaps", "alerting:apm.transaction_duration/observability/rule/get", + "alerting:apm.transaction_duration/observability/rule/bulkGet", "alerting:apm.transaction_duration/observability/rule/getRuleState", "alerting:apm.transaction_duration/observability/rule/getAlertSummary", "alerting:apm.transaction_duration/observability/rule/getExecutionLog", @@ -27793,6 +28714,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/observability/rule/findBackfill", "alerting:apm.transaction_duration/observability/rule/findGaps", "alerting:apm.transaction_duration/alerts/rule/get", + "alerting:apm.transaction_duration/alerts/rule/bulkGet", "alerting:apm.transaction_duration/alerts/rule/getRuleState", "alerting:apm.transaction_duration/alerts/rule/getAlertSummary", "alerting:apm.transaction_duration/alerts/rule/getExecutionLog", @@ -27803,6 +28725,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.transaction_duration/alerts/rule/findBackfill", "alerting:apm.transaction_duration/alerts/rule/findGaps", "alerting:apm.anomaly/observability/rule/get", + "alerting:apm.anomaly/observability/rule/bulkGet", "alerting:apm.anomaly/observability/rule/getRuleState", "alerting:apm.anomaly/observability/rule/getAlertSummary", "alerting:apm.anomaly/observability/rule/getExecutionLog", @@ -27813,6 +28736,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/observability/rule/findBackfill", "alerting:apm.anomaly/observability/rule/findGaps", "alerting:apm.anomaly/alerts/rule/get", + "alerting:apm.anomaly/alerts/rule/bulkGet", "alerting:apm.anomaly/alerts/rule/getRuleState", "alerting:apm.anomaly/alerts/rule/getAlertSummary", "alerting:apm.anomaly/alerts/rule/getExecutionLog", @@ -27823,6 +28747,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:apm.anomaly/alerts/rule/findBackfill", "alerting:apm.anomaly/alerts/rule/findGaps", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -27833,6 +28758,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.synthetics.alerts.tls/observability/rule/get", + "alerting:xpack.synthetics.alerts.tls/observability/rule/bulkGet", "alerting:xpack.synthetics.alerts.tls/observability/rule/getRuleState", "alerting:xpack.synthetics.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.synthetics.alerts.tls/observability/rule/getExecutionLog", @@ -27843,6 +28769,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.synthetics.alerts.tls/observability/rule/findBackfill", "alerting:xpack.synthetics.alerts.tls/observability/rule/findGaps", "alerting:metrics.alert.threshold/observability/rule/get", + "alerting:metrics.alert.threshold/observability/rule/bulkGet", "alerting:metrics.alert.threshold/observability/rule/getRuleState", "alerting:metrics.alert.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.threshold/observability/rule/getExecutionLog", @@ -27853,6 +28780,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/observability/rule/findBackfill", "alerting:metrics.alert.threshold/observability/rule/findGaps", "alerting:metrics.alert.threshold/alerts/rule/get", + "alerting:metrics.alert.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.threshold/alerts/rule/getExecutionLog", @@ -27863,6 +28791,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.threshold/alerts/rule/findGaps", "alerting:metrics.alert.inventory.threshold/observability/rule/get", + "alerting:metrics.alert.inventory.threshold/observability/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/observability/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/observability/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/observability/rule/getExecutionLog", @@ -27873,6 +28802,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/observability/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/observability/rule/findGaps", "alerting:metrics.alert.inventory.threshold/alerts/rule/get", + "alerting:metrics.alert.inventory.threshold/alerts/rule/bulkGet", "alerting:metrics.alert.inventory.threshold/alerts/rule/getRuleState", "alerting:metrics.alert.inventory.threshold/alerts/rule/getAlertSummary", "alerting:metrics.alert.inventory.threshold/alerts/rule/getExecutionLog", @@ -27883,6 +28813,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:metrics.alert.inventory.threshold/alerts/rule/findBackfill", "alerting:metrics.alert.inventory.threshold/alerts/rule/findGaps", "alerting:xpack.uptime.alerts.tls/observability/rule/get", + "alerting:xpack.uptime.alerts.tls/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tls/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tls/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tls/observability/rule/getExecutionLog", @@ -27893,6 +28824,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tls/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tls/observability/rule/findGaps", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/get", + "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/getExecutionLog", @@ -27903,6 +28835,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.tlsCertificate/observability/rule/findGaps", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/get", + "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/getExecutionLog", @@ -27913,6 +28846,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.monitorStatus/observability/rule/findGaps", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/get", + "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/bulkGet", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getRuleState", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getAlertSummary", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/getExecutionLog", @@ -27923,6 +28857,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findBackfill", "alerting:xpack.uptime.alerts.durationAnomaly/observability/rule/findGaps", "alerting:logs.alert.document.count/observability/rule/get", + "alerting:logs.alert.document.count/observability/rule/bulkGet", "alerting:logs.alert.document.count/observability/rule/getRuleState", "alerting:logs.alert.document.count/observability/rule/getAlertSummary", "alerting:logs.alert.document.count/observability/rule/getExecutionLog", @@ -27933,6 +28868,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/observability/rule/findBackfill", "alerting:logs.alert.document.count/observability/rule/findGaps", "alerting:logs.alert.document.count/alerts/rule/get", + "alerting:logs.alert.document.count/alerts/rule/bulkGet", "alerting:logs.alert.document.count/alerts/rule/getRuleState", "alerting:logs.alert.document.count/alerts/rule/getAlertSummary", "alerting:logs.alert.document.count/alerts/rule/getExecutionLog", @@ -27943,6 +28879,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:logs.alert.document.count/alerts/rule/findBackfill", "alerting:logs.alert.document.count/alerts/rule/findGaps", "alerting:slo.rules.burnRate/observability/rule/get", + "alerting:slo.rules.burnRate/observability/rule/bulkGet", "alerting:slo.rules.burnRate/observability/rule/getRuleState", "alerting:slo.rules.burnRate/observability/rule/getAlertSummary", "alerting:slo.rules.burnRate/observability/rule/getExecutionLog", @@ -27953,6 +28890,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/observability/rule/findBackfill", "alerting:slo.rules.burnRate/observability/rule/findGaps", "alerting:slo.rules.burnRate/alerts/rule/get", + "alerting:slo.rules.burnRate/alerts/rule/bulkGet", "alerting:slo.rules.burnRate/alerts/rule/getRuleState", "alerting:slo.rules.burnRate/alerts/rule/getAlertSummary", "alerting:slo.rules.burnRate/alerts/rule/getExecutionLog", @@ -27963,6 +28901,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:slo.rules.burnRate/alerts/rule/findBackfill", "alerting:slo.rules.burnRate/alerts/rule/findGaps", "alerting:observability.rules.custom_threshold/observability/rule/get", + "alerting:observability.rules.custom_threshold/observability/rule/bulkGet", "alerting:observability.rules.custom_threshold/observability/rule/getRuleState", "alerting:observability.rules.custom_threshold/observability/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/observability/rule/getExecutionLog", @@ -27973,6 +28912,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/observability/rule/findBackfill", "alerting:observability.rules.custom_threshold/observability/rule/findGaps", "alerting:observability.rules.custom_threshold/alerts/rule/get", + "alerting:observability.rules.custom_threshold/alerts/rule/bulkGet", "alerting:observability.rules.custom_threshold/alerts/rule/getRuleState", "alerting:observability.rules.custom_threshold/alerts/rule/getAlertSummary", "alerting:observability.rules.custom_threshold/alerts/rule/getExecutionLog", @@ -27983,6 +28923,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:observability.rules.custom_threshold/alerts/rule/findBackfill", "alerting:observability.rules.custom_threshold/alerts/rule/findGaps", "alerting:.es-query/observability/rule/get", + "alerting:.es-query/observability/rule/bulkGet", "alerting:.es-query/observability/rule/getRuleState", "alerting:.es-query/observability/rule/getAlertSummary", "alerting:.es-query/observability/rule/getExecutionLog", @@ -27993,6 +28934,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/observability/rule/findBackfill", "alerting:.es-query/observability/rule/findGaps", "alerting:.es-query/alerts/rule/get", + "alerting:.es-query/alerts/rule/bulkGet", "alerting:.es-query/alerts/rule/getRuleState", "alerting:.es-query/alerts/rule/getAlertSummary", "alerting:.es-query/alerts/rule/getExecutionLog", @@ -28003,6 +28945,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:.es-query/alerts/rule/findBackfill", "alerting:.es-query/alerts/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/observability/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/getExecutionLog", @@ -28013,6 +28956,7 @@ export default function ({ getService }: FtrProviderContext) { "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findBackfill", "alerting:xpack.ml.anomaly_detection_alert/observability/rule/findGaps", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/get", + "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/bulkGet", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getRuleState", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getAlertSummary", "alerting:xpack.ml.anomaly_detection_alert/alerts/rule/getExecutionLog",