From 9b6bb25b1fe07ba4537a45acd390dab39b2a93e2 Mon Sep 17 00:00:00 2001 From: Dario Gieselaar Date: Mon, 3 May 2021 13:52:54 +0200 Subject: [PATCH 1/7] Instrument task manager --- packages/kbn-apm-utils/src/index.ts | 14 +- .../actions/server/lib/action_executor.ts | 223 ++++++++++-------- .../server/queries/task_claiming.ts | 61 ++--- .../server/saved_objects/mappings.json | 3 + x-pack/plugins/task_manager/server/task.ts | 3 + .../server/task_running/task_runner.ts | 40 ++-- .../task_manager/server/task_scheduling.ts | 6 +- 7 files changed, 202 insertions(+), 148 deletions(-) diff --git a/packages/kbn-apm-utils/src/index.ts b/packages/kbn-apm-utils/src/index.ts index f2f537138dad07..384b6683199e5b 100644 --- a/packages/kbn-apm-utils/src/index.ts +++ b/packages/kbn-apm-utils/src/index.ts @@ -16,6 +16,8 @@ export interface SpanOptions { labels?: Record; } +type Span = Exclude; + export function parseSpanOptions(optionsOrName: SpanOptions | string) { const options = typeof optionsOrName === 'string' ? { name: optionsOrName } : optionsOrName; @@ -30,7 +32,7 @@ const runInNewContext = any>(cb: T): ReturnType( optionsOrName: SpanOptions | string, - cb: () => Promise + cb: (span?: Span) => Promise ): Promise { const options = parseSpanOptions(optionsOrName); @@ -71,13 +73,17 @@ export async function withSpan( span.addLabels(labels); } - return cb() + return cb(span) .then((res) => { - span.outcome = 'success'; + if (!span.outcome || span.outcome === 'unknown') { + span.outcome = 'success'; + } return res; }) .catch((err) => { - span.outcome = 'failure'; + if (!span.outcome || span.outcome === 'unknown') { + span.outcome = 'failure'; + } throw err; }) .finally(() => { diff --git a/x-pack/plugins/actions/server/lib/action_executor.ts b/x-pack/plugins/actions/server/lib/action_executor.ts index 6deaa4d587904d..b1b2d64f28de10 100644 --- a/x-pack/plugins/actions/server/lib/action_executor.ts +++ b/x-pack/plugins/actions/server/lib/action_executor.ts @@ -7,6 +7,7 @@ import type { PublicMethodsOf } from '@kbn/utility-types'; import { Logger, KibanaRequest } from 'src/core/server'; +import { withSpan } from '@kbn/apm-utils'; import { validateParams, validateConfig, validateSecrets } from './validate_with_schema'; import { ActionTypeExecutorResult, @@ -78,113 +79,135 @@ export class ActionExecutor { ); } - const { - logger, - spaces, - getServices, - encryptedSavedObjectsClient, - actionTypeRegistry, - eventLogger, - preconfiguredActions, - getActionsClientWithRequest, - } = this.actionExecutorContext!; - - const services = getServices(request); - const spaceId = spaces && spaces.getSpaceId(request); - const namespace = spaceId && spaceId !== 'default' ? { namespace: spaceId } : {}; - - const { actionTypeId, name, config, secrets } = await getActionInfo( - await getActionsClientWithRequest(request, source), - encryptedSavedObjectsClient, - preconfiguredActions, - actionId, - namespace.namespace - ); + return withSpan( + { + name: `execute_action`, + type: 'actions', + labels: { + actionId, + }, + }, + async (span) => { + const { + logger, + spaces, + getServices, + encryptedSavedObjectsClient, + actionTypeRegistry, + eventLogger, + preconfiguredActions, + getActionsClientWithRequest, + } = this.actionExecutorContext!; - if (!actionTypeRegistry.isActionExecutable(actionId, actionTypeId, { notifyUsage: true })) { - actionTypeRegistry.ensureActionTypeEnabled(actionTypeId); - } - const actionType = actionTypeRegistry.get(actionTypeId); - - let validatedParams: Record; - let validatedConfig: Record; - let validatedSecrets: Record; - - try { - validatedParams = validateParams(actionType, params); - validatedConfig = validateConfig(actionType, config); - validatedSecrets = validateSecrets(actionType, secrets); - } catch (err) { - return { status: 'error', actionId, message: err.message, retry: false }; - } + const services = getServices(request); + const spaceId = spaces && spaces.getSpaceId(request); + const namespace = spaceId && spaceId !== 'default' ? { namespace: spaceId } : {}; + + const { actionTypeId, name, config, secrets } = await getActionInfo( + await getActionsClientWithRequest(request, source), + encryptedSavedObjectsClient, + preconfiguredActions, + actionId, + namespace.namespace + ); + + if (span) { + span.name = `execute_action ${actionTypeId}`; + span.addLabels({ + actionTypeId, + }); + } + + if (!actionTypeRegistry.isActionExecutable(actionId, actionTypeId, { notifyUsage: true })) { + actionTypeRegistry.ensureActionTypeEnabled(actionTypeId); + } + const actionType = actionTypeRegistry.get(actionTypeId); + + let validatedParams: Record; + let validatedConfig: Record; + let validatedSecrets: Record; + + try { + validatedParams = validateParams(actionType, params); + validatedConfig = validateConfig(actionType, config); + validatedSecrets = validateSecrets(actionType, secrets); + } catch (err) { + span?.setOutcome('failure'); + return { status: 'error', actionId, message: err.message, retry: false }; + } - const actionLabel = `${actionTypeId}:${actionId}: ${name}`; - logger.debug(`executing action ${actionLabel}`); - - const event: IEvent = { - event: { action: EVENT_LOG_ACTIONS.execute }, - kibana: { - saved_objects: [ - { - rel: SAVED_OBJECT_REL_PRIMARY, - type: 'action', - id: actionId, - ...namespace, + const actionLabel = `${actionTypeId}:${actionId}: ${name}`; + logger.debug(`executing action ${actionLabel}`); + + const event: IEvent = { + event: { action: EVENT_LOG_ACTIONS.execute }, + kibana: { + saved_objects: [ + { + rel: SAVED_OBJECT_REL_PRIMARY, + type: 'action', + id: actionId, + ...namespace, + }, + ], }, - ], - }, - }; + }; - eventLogger.startTiming(event); - let rawResult: ActionTypeExecutorResult; - try { - rawResult = await actionType.executor({ - actionId, - services, - params: validatedParams, - config: validatedConfig, - secrets: validatedSecrets, - }); - } catch (err) { - rawResult = { - actionId, - status: 'error', - message: 'an error occurred while running the action executor', - serviceMessage: err.message, - retry: false, - }; - } - eventLogger.stopTiming(event); + eventLogger.startTiming(event); + let rawResult: ActionTypeExecutorResult; + try { + rawResult = await actionType.executor({ + actionId, + services, + params: validatedParams, + config: validatedConfig, + secrets: validatedSecrets, + }); + } catch (err) { + rawResult = { + actionId, + status: 'error', + message: 'an error occurred while running the action executor', + serviceMessage: err.message, + retry: false, + }; + } + eventLogger.stopTiming(event); - // allow null-ish return to indicate success - const result = rawResult || { - actionId, - status: 'ok', - }; + // allow null-ish return to indicate success + const result = rawResult || { + actionId, + status: 'ok', + }; - event.event = event.event || {}; - - if (result.status === 'ok') { - event.event.outcome = 'success'; - event.message = `action executed: ${actionLabel}`; - } else if (result.status === 'error') { - event.event.outcome = 'failure'; - event.message = `action execution failure: ${actionLabel}`; - event.error = event.error || {}; - event.error.message = actionErrorToMessage(result); - logger.warn(`action execution failure: ${actionLabel}: ${event.error.message}`); - } else { - event.event.outcome = 'failure'; - event.message = `action execution returned unexpected result: ${actionLabel}: "${result.status}"`; - event.error = event.error || {}; - event.error.message = 'action execution returned unexpected result'; - logger.warn( - `action execution failure: ${actionLabel}: returned unexpected result "${result.status}"` - ); - } + event.event = event.event || {}; - eventLogger.logEvent(event); - return result; + if (result.status === 'ok') { + span?.setOutcome('success'); + event.event.outcome = 'success'; + event.message = `action executed: ${actionLabel}`; + } else if (result.status === 'error') { + span?.setOutcome('failure'); + event.event.outcome = 'failure'; + event.message = `action execution failure: ${actionLabel}`; + event.error = event.error || {}; + event.error.message = actionErrorToMessage(result); + logger.warn(`action execution failure: ${actionLabel}: ${event.error.message}`); + } else { + span?.setOutcome('failure'); + event.event.outcome = 'failure'; + event.message = `action execution returned unexpected result: ${actionLabel}: "${result.status}"`; + event.error = event.error || {}; + event.error.message = 'action execution returned unexpected result'; + logger.warn( + `action execution failure: ${actionLabel}: returned unexpected result "${result.status}"` + ); + } + + eventLogger.logEvent(event); + return result; + } + ); } } diff --git a/x-pack/plugins/task_manager/server/queries/task_claiming.ts b/x-pack/plugins/task_manager/server/queries/task_claiming.ts index dce78242816583..7f15707a14b308 100644 --- a/x-pack/plugins/task_manager/server/queries/task_claiming.ts +++ b/x-pack/plugins/task_manager/server/queries/task_claiming.ts @@ -379,34 +379,41 @@ export class TaskClaiming { sort.unshift('_score'); } - const apmTrans = apm.startTransaction(`taskManager markAvailableTasksAsClaimed`, 'taskManager'); - const result = await this.taskStore.updateByQuery( - { - query: matchesClauses( - claimTasksById && claimTasksById.length - ? mustBeAllOf(asPinnedQuery(claimTasksById, queryForScheduledTasks)) - : queryForScheduledTasks, - filterDownBy(InactiveTasks) - ), - script: updateFieldsAndMarkAsFailed( - { - ownerId: this.taskStore.taskManagerId, - retryAt: claimOwnershipUntil, - }, - claimTasksById || [], - taskTypesToClaim, - taskTypesToSkip, - pick(this.taskMaxAttempts, taskTypesToClaim) - ), - sort, - }, - { - max_docs: size, - } + const apmTrans = apm.startTransaction( + 'markAvailableTasksAsClaimed', + `taskManager markAvailableTasksAsClaimed` ); - - if (apmTrans) apmTrans.end(); - return result; + try { + const result = await this.taskStore.updateByQuery( + { + query: matchesClauses( + claimTasksById && claimTasksById.length + ? mustBeAllOf(asPinnedQuery(claimTasksById, queryForScheduledTasks)) + : queryForScheduledTasks, + filterDownBy(InactiveTasks) + ), + script: updateFieldsAndMarkAsFailed( + { + ownerId: this.taskStore.taskManagerId, + retryAt: claimOwnershipUntil, + }, + claimTasksById || [], + taskTypesToClaim, + taskTypesToSkip, + pick(this.taskMaxAttempts, taskTypesToClaim) + ), + sort, + }, + { + max_docs: size, + } + ); + apmTrans?.end('success'); + return result; + } catch (err) { + apmTrans?.end('failure'); + throw err; + } } /** diff --git a/x-pack/plugins/task_manager/server/saved_objects/mappings.json b/x-pack/plugins/task_manager/server/saved_objects/mappings.json index 1728c8f1c552bd..d046a9266cce52 100644 --- a/x-pack/plugins/task_manager/server/saved_objects/mappings.json +++ b/x-pack/plugins/task_manager/server/saved_objects/mappings.json @@ -29,6 +29,9 @@ "status": { "type": "keyword" }, + "traceparent": { + "type": "text" + }, "params": { "type": "text" }, diff --git a/x-pack/plugins/task_manager/server/task.ts b/x-pack/plugins/task_manager/server/task.ts index 4b86943ff8eca2..28aac04f8fa0f5 100644 --- a/x-pack/plugins/task_manager/server/task.ts +++ b/x-pack/plugins/task_manager/server/task.ts @@ -257,6 +257,8 @@ export interface TaskInstance { // eslint-disable-next-line @typescript-eslint/no-explicit-any state: Record; + traceparent?: string; + /** * The id of the user who scheduled this task. */ @@ -364,6 +366,7 @@ export type SerializedConcreteTaskInstance = Omit< > & { state: string; params: string; + traceparent: string; scheduledAt: string; startedAt: string | null; retryAt: string | null; diff --git a/x-pack/plugins/task_manager/server/task_running/task_runner.ts b/x-pack/plugins/task_manager/server/task_running/task_runner.ts index 8e061eae460280..cf712cb5af38bb 100644 --- a/x-pack/plugins/task_manager/server/task_running/task_runner.ts +++ b/x-pack/plugins/task_manager/server/task_running/task_runner.ts @@ -12,6 +12,7 @@ */ import apm from 'elastic-apm-node'; +import { withSpan } from '@kbn/apm-utils'; import { performance } from 'perf_hooks'; import { identity, defaults, flow } from 'lodash'; import { Logger, SavedObjectsErrorHelpers } from '../../../../../src/core/server'; @@ -242,30 +243,40 @@ export class TaskManagerRunner implements TaskRunner { ); } this.logger.debug(`Running task ${this}`); - const modifiedContext = await this.beforeRun({ - taskInstance: this.instance.task, + + const apmTrans = apm.startTransaction(this.taskType, 'taskManager run', { + childOf: this.instance.task.traceparent, }); + const modifiedContext = await withSpan({ name: 'before run', type: 'task manager' }, () => + this.beforeRun({ + taskInstance: this.instance.task, + }) + ); + const stopTaskTimer = startTaskTimer(); - const apmTrans = apm.startTransaction(`taskManager run`, 'taskManager'); - apmTrans?.addLabels({ - taskType: this.taskType, - }); + try { this.task = this.definition.createTaskRunner(modifiedContext); - const result = await this.task.run(); + const result = await withSpan({ name: 'run', type: 'task manager' }, () => this.task!.run()); const validatedResult = this.validateResult(result); + const processedResult = await withSpan({ name: 'process result', type: 'task manager' }, () => + this.processResult(validatedResult, stopTaskTimer()) + ); if (apmTrans) apmTrans.end('success'); - return this.processResult(validatedResult, stopTaskTimer()); + return processedResult; } catch (err) { this.logger.error(`Task ${this} failed: ${err}`); // in error scenario, we can not get the RunResult // re-use modifiedContext's state, which is correct as of beforeRun - if (apmTrans) apmTrans.end('error'); - return this.processResult( - asErr({ error: err, state: modifiedContext.taskInstance.state }), - stopTaskTimer() + const processedResult = await withSpan({ name: 'process result', type: 'task manager' }, () => + this.processResult( + asErr({ error: err, state: modifiedContext.taskInstance.state }), + stopTaskTimer() + ) ); + if (apmTrans) apmTrans.end('failure'); + return processedResult; } } @@ -285,10 +296,7 @@ export class TaskManagerRunner implements TaskRunner { } performance.mark('markTaskAsRunning_start'); - const apmTrans = apm.startTransaction(`taskManager markTaskAsRunning`, 'taskManager'); - apmTrans?.addLabels({ - taskType: this.taskType, - }); + const apmTrans = apm.startTransaction('taskManager', 'taskManager markTaskAsRunning'); const now = new Date(); try { diff --git a/x-pack/plugins/task_manager/server/task_scheduling.ts b/x-pack/plugins/task_manager/server/task_scheduling.ts index 29e83ec911b795..153c16f5c4bf78 100644 --- a/x-pack/plugins/task_manager/server/task_scheduling.ts +++ b/x-pack/plugins/task_manager/server/task_scheduling.ts @@ -10,6 +10,7 @@ import { filter } from 'rxjs/operators'; import { pipe } from 'fp-ts/lib/pipeable'; import { Option, map as mapOptional, getOrElse, isSome } from 'fp-ts/lib/Option'; +import agent from 'elastic-apm-node'; import { Logger } from '../../../../src/core/server'; import { asOk, either, map, mapErr, promiseResult } from './lib/result_type'; import { @@ -85,7 +86,10 @@ export class TaskScheduling { ...options, taskInstance: ensureDeprecatedFieldsAreCorrected(taskInstance, this.logger), }); - return await this.store.schedule(modifiedTask); + return await this.store.schedule({ + ...modifiedTask, + traceparent: agent.currentTraceparent ?? '', + }); } /** From 54f848dc0c6236d617f5209048a2cebcb1ab61f3 Mon Sep 17 00:00:00 2001 From: Dario Gieselaar Date: Mon, 3 May 2021 14:14:52 +0200 Subject: [PATCH 2/7] Don't refresh after SO updates --- x-pack/plugins/actions/server/actions_client.ts | 2 +- x-pack/plugins/actions/server/create_execute_function.ts | 5 ++++- x-pack/plugins/actions/server/lib/task_runner_factory.ts | 7 +++---- x-pack/plugins/task_manager/server/task_store.ts | 2 +- 4 files changed, 9 insertions(+), 7 deletions(-) diff --git a/x-pack/plugins/actions/server/actions_client.ts b/x-pack/plugins/actions/server/actions_client.ts index c655141415b548..eb8f24f4613352 100644 --- a/x-pack/plugins/actions/server/actions_client.ts +++ b/x-pack/plugins/actions/server/actions_client.ts @@ -462,7 +462,7 @@ export class ActionsClient { }) ); - return await this.unsecuredSavedObjectsClient.delete('action', id); + return await this.unsecuredSavedObjectsClient.delete('action', id, { refresh: false }); } public async execute({ diff --git a/x-pack/plugins/actions/server/create_execute_function.ts b/x-pack/plugins/actions/server/create_execute_function.ts index 025b4d31077985..562e0823327e87 100644 --- a/x-pack/plugins/actions/server/create_execute_function.ts +++ b/x-pack/plugins/actions/server/create_execute_function.ts @@ -63,7 +63,10 @@ export function createExecutionEnqueuerFunction({ params, apiKey, }, - executionSourceAsSavedObjectReferences(source) + { + ...executionSourceAsSavedObjectReferences(source), + refresh: false, + } ); await taskManager.schedule({ diff --git a/x-pack/plugins/actions/server/lib/task_runner_factory.ts b/x-pack/plugins/actions/server/lib/task_runner_factory.ts index 7481b70d1eaeb8..9cbb483655fad1 100644 --- a/x-pack/plugins/actions/server/lib/task_runner_factory.ts +++ b/x-pack/plugins/actions/server/lib/task_runner_factory.ts @@ -142,10 +142,9 @@ export class TaskRunnerFactory { // We would idealy secure every operation but in order to support clean up of legacy alerts // we allow this operation in an unsecured manner // Once support for legacy alert RBAC is dropped, this can be secured - await getUnsecuredSavedObjectsClient(fakeRequest).delete( - ACTION_TASK_PARAMS_SAVED_OBJECT_TYPE, - actionTaskParamsId - ); + await getUnsecuredSavedObjectsClient( + fakeRequest + ).delete(ACTION_TASK_PARAMS_SAVED_OBJECT_TYPE, actionTaskParamsId, { refresh: false }); } catch (e) { // Log error only, we shouldn't fail the task because of an error here (if ever there's retry logic) logger.error( diff --git a/x-pack/plugins/task_manager/server/task_store.ts b/x-pack/plugins/task_manager/server/task_store.ts index af0adad43baa46..51e74f2c20f88f 100644 --- a/x-pack/plugins/task_manager/server/task_store.ts +++ b/x-pack/plugins/task_manager/server/task_store.ts @@ -258,7 +258,7 @@ export class TaskStore { */ public async remove(id: string): Promise { try { - await this.savedObjectsRepository.delete('task', id); + await this.savedObjectsRepository.delete('task', id, { refresh: false }); } catch (e) { this.errors$.next(e); throw e; From 4e04a61fae946ab361ea0664a445423a4f49d070 Mon Sep 17 00:00:00 2001 From: Dario Gieselaar Date: Tue, 4 May 2021 11:57:18 +0200 Subject: [PATCH 3/7] Update snapshot test, remove beforeRun instrumentation --- .../task_manager/server/task_running/task_runner.ts | 8 +++----- x-pack/plugins/task_manager/server/task_store.test.ts | 2 +- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/x-pack/plugins/task_manager/server/task_running/task_runner.ts b/x-pack/plugins/task_manager/server/task_running/task_runner.ts index cf712cb5af38bb..fc88a66329170f 100644 --- a/x-pack/plugins/task_manager/server/task_running/task_runner.ts +++ b/x-pack/plugins/task_manager/server/task_running/task_runner.ts @@ -248,11 +248,9 @@ export class TaskManagerRunner implements TaskRunner { childOf: this.instance.task.traceparent, }); - const modifiedContext = await withSpan({ name: 'before run', type: 'task manager' }, () => - this.beforeRun({ - taskInstance: this.instance.task, - }) - ); + const modifiedContext = await this.beforeRun({ + taskInstance: this.instance.task, + }); const stopTaskTimer = startTaskTimer(); diff --git a/x-pack/plugins/task_manager/server/task_store.test.ts b/x-pack/plugins/task_manager/server/task_store.test.ts index a44bddcdb82014..83bfaddb9c460a 100644 --- a/x-pack/plugins/task_manager/server/task_store.test.ts +++ b/x-pack/plugins/task_manager/server/task_store.test.ts @@ -413,7 +413,7 @@ describe('TaskStore', () => { const id = randomId(); const result = await store.remove(id); expect(result).toBeUndefined(); - expect(savedObjectsClient.delete).toHaveBeenCalledWith('task', id); + expect(savedObjectsClient.delete).toHaveBeenCalledWith('task', id, { refresh: false }); }); test('pushes error from saved objects client to errors$', async () => { From bad492c7b0c99a4468f1bde86485d6bfe8692a02 Mon Sep 17 00:00:00 2001 From: Dario Gieselaar Date: Wed, 12 May 2021 15:30:18 +0200 Subject: [PATCH 4/7] Revert "Don't refresh after SO updates" This reverts commit 54f848dc0c6236d617f5209048a2cebcb1ab61f3. --- x-pack/plugins/actions/server/actions_client.ts | 2 +- x-pack/plugins/actions/server/create_execute_function.ts | 5 +---- x-pack/plugins/actions/server/lib/task_runner_factory.ts | 7 ++++--- x-pack/plugins/task_manager/server/task_store.ts | 2 +- 4 files changed, 7 insertions(+), 9 deletions(-) diff --git a/x-pack/plugins/actions/server/actions_client.ts b/x-pack/plugins/actions/server/actions_client.ts index eb8f24f4613352..c655141415b548 100644 --- a/x-pack/plugins/actions/server/actions_client.ts +++ b/x-pack/plugins/actions/server/actions_client.ts @@ -462,7 +462,7 @@ export class ActionsClient { }) ); - return await this.unsecuredSavedObjectsClient.delete('action', id, { refresh: false }); + return await this.unsecuredSavedObjectsClient.delete('action', id); } public async execute({ diff --git a/x-pack/plugins/actions/server/create_execute_function.ts b/x-pack/plugins/actions/server/create_execute_function.ts index b52d9235627529..4f3ffbef36c6e2 100644 --- a/x-pack/plugins/actions/server/create_execute_function.ts +++ b/x-pack/plugins/actions/server/create_execute_function.ts @@ -69,10 +69,7 @@ export function createExecutionEnqueuerFunction({ params, apiKey, }, - { - ...executionSourceAsSavedObjectReferences(source), - refresh: false, - } + executionSourceAsSavedObjectReferences(source) ); await taskManager.schedule({ diff --git a/x-pack/plugins/actions/server/lib/task_runner_factory.ts b/x-pack/plugins/actions/server/lib/task_runner_factory.ts index faddb62f4dee07..cf4b1576f27786 100644 --- a/x-pack/plugins/actions/server/lib/task_runner_factory.ts +++ b/x-pack/plugins/actions/server/lib/task_runner_factory.ts @@ -142,9 +142,10 @@ export class TaskRunnerFactory { // We would idealy secure every operation but in order to support clean up of legacy alerts // we allow this operation in an unsecured manner // Once support for legacy alert RBAC is dropped, this can be secured - await getUnsecuredSavedObjectsClient( - fakeRequest - ).delete(ACTION_TASK_PARAMS_SAVED_OBJECT_TYPE, actionTaskParamsId, { refresh: false }); + await getUnsecuredSavedObjectsClient(fakeRequest).delete( + ACTION_TASK_PARAMS_SAVED_OBJECT_TYPE, + actionTaskParamsId + ); } catch (e) { // Log error only, we shouldn't fail the task because of an error here (if ever there's retry logic) logger.error( diff --git a/x-pack/plugins/task_manager/server/task_store.ts b/x-pack/plugins/task_manager/server/task_store.ts index 1df23334889480..0eeccd0af75f77 100644 --- a/x-pack/plugins/task_manager/server/task_store.ts +++ b/x-pack/plugins/task_manager/server/task_store.ts @@ -258,7 +258,7 @@ export class TaskStore { */ public async remove(id: string): Promise { try { - await this.savedObjectsRepository.delete('task', id, { refresh: false }); + await this.savedObjectsRepository.delete('task', id); } catch (e) { this.errors$.next(e); throw e; From 86af7431b4cf4bd941ad49b9b170038a2a6ed025 Mon Sep 17 00:00:00 2001 From: Dario Gieselaar Date: Wed, 12 May 2021 16:47:42 +0200 Subject: [PATCH 5/7] Fix task_store unit test --- x-pack/plugins/task_manager/server/task_store.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/x-pack/plugins/task_manager/server/task_store.test.ts b/x-pack/plugins/task_manager/server/task_store.test.ts index 83bfaddb9c460a..a44bddcdb82014 100644 --- a/x-pack/plugins/task_manager/server/task_store.test.ts +++ b/x-pack/plugins/task_manager/server/task_store.test.ts @@ -413,7 +413,7 @@ describe('TaskStore', () => { const id = randomId(); const result = await store.remove(id); expect(result).toBeUndefined(); - expect(savedObjectsClient.delete).toHaveBeenCalledWith('task', id, { refresh: false }); + expect(savedObjectsClient.delete).toHaveBeenCalledWith('task', id); }); test('pushes error from saved objects client to errors$', async () => { From 0be04d6bad21592db3ff0bab3298b5ae33e7ee13 Mon Sep 17 00:00:00 2001 From: Ying Mao Date: Tue, 25 May 2021 14:20:10 -0400 Subject: [PATCH 6/7] Adding tests and updating ConcreteTaskInstance interface with traceparent --- .../task_runner.test.ts | 1 + .../server/lib/task_runner_factory.test.ts | 1 + .../server/buffered_task_store.test.ts | 1 + .../task_manager/server/lib/fill_pool.test.ts | 1 + .../monitoring/task_run_statistics.test.ts | 1 + .../server/queries/task_claiming.test.ts | 74 +++++++++++- x-pack/plugins/task_manager/server/task.ts | 8 ++ .../server/task_running/task_runner.test.ts | 113 ++++++++++++++++++ .../server/task_scheduling.test.ts | 11 ++ .../task_manager/server/task_store.test.ts | 8 ++ .../plugins/task_manager/server/task_store.ts | 2 + 11 files changed, 220 insertions(+), 1 deletion(-) diff --git a/x-pack/plugins/actions/server/cleanup_failed_executions/task_runner.test.ts b/x-pack/plugins/actions/server/cleanup_failed_executions/task_runner.test.ts index d465e532b0284f..4062869f373f37 100644 --- a/x-pack/plugins/actions/server/cleanup_failed_executions/task_runner.test.ts +++ b/x-pack/plugins/actions/server/cleanup_failed_executions/task_runner.test.ts @@ -53,6 +53,7 @@ describe('taskRunner', () => { ownerId: '234', taskType: 'foo', params: {}, + traceparent: '', }; beforeEach(() => { diff --git a/x-pack/plugins/actions/server/lib/task_runner_factory.test.ts b/x-pack/plugins/actions/server/lib/task_runner_factory.test.ts index 229324c1f0df38..67afd806646ca2 100644 --- a/x-pack/plugins/actions/server/lib/task_runner_factory.test.ts +++ b/x-pack/plugins/actions/server/lib/task_runner_factory.test.ts @@ -44,6 +44,7 @@ beforeAll(() => { actionTaskParamsId: '3', }, taskType: 'actions:1', + traceparent: '', }; taskRunnerFactory = new TaskRunnerFactory(mockedActionExecutor); mockedActionExecutor.initialize(actionExecutorInitializerParams); diff --git a/x-pack/plugins/task_manager/server/buffered_task_store.test.ts b/x-pack/plugins/task_manager/server/buffered_task_store.test.ts index 45607713a31287..7c1e6f24127c21 100644 --- a/x-pack/plugins/task_manager/server/buffered_task_store.test.ts +++ b/x-pack/plugins/task_manager/server/buffered_task_store.test.ts @@ -110,5 +110,6 @@ function mockTask() { user: undefined, version: '123', ownerId: '123', + traceparent: '', }; } diff --git a/x-pack/plugins/task_manager/server/lib/fill_pool.test.ts b/x-pack/plugins/task_manager/server/lib/fill_pool.test.ts index 8e0396a453b3d9..205e3312fbd14e 100644 --- a/x-pack/plugins/task_manager/server/lib/fill_pool.test.ts +++ b/x-pack/plugins/task_manager/server/lib/fill_pool.test.ts @@ -54,6 +54,7 @@ describe('fillPool', () => { taskType: '', params: {}, ownerId: null, + traceparent: '', })); test('fills task pool with all claimed tasks until fetchAvailableTasks stream closes', async () => { diff --git a/x-pack/plugins/task_manager/server/monitoring/task_run_statistics.test.ts b/x-pack/plugins/task_manager/server/monitoring/task_run_statistics.test.ts index 7040d5acd4eaf3..d47bd142856062 100644 --- a/x-pack/plugins/task_manager/server/monitoring/task_run_statistics.test.ts +++ b/x-pack/plugins/task_manager/server/monitoring/task_run_statistics.test.ts @@ -591,6 +591,7 @@ const mockTaskInstance = (overrides: Partial = {}): Concre alertId: '1', }, ownerId: null, + traceparent: '', ...overrides, }); diff --git a/x-pack/plugins/task_manager/server/queries/task_claiming.test.ts b/x-pack/plugins/task_manager/server/queries/task_claiming.test.ts index 8f1332ccd1f9f7..ee185ac6ce6bb6 100644 --- a/x-pack/plugins/task_manager/server/queries/task_claiming.test.ts +++ b/x-pack/plugins/task_manager/server/queries/task_claiming.test.ts @@ -20,10 +20,11 @@ import { mockLogger } from '../test_utils'; import { TaskClaiming, OwnershipClaimingOpts, TaskClaimingOpts } from './task_claiming'; import { Observable } from 'rxjs'; import { taskStoreMock } from '../task_store.mock'; +import apm from 'elastic-apm-node'; const taskManagerLogger = mockLogger(); -beforeEach(() => jest.resetAllMocks()); +beforeEach(() => jest.clearAllMocks()); const mockedDate = new Date('2019-02-12T21:01:22.479Z'); // eslint-disable-next-line @typescript-eslint/no-explicit-any @@ -52,7 +53,19 @@ taskDefinitions.registerTaskDefinitions({ }, }); +const mockApmTrans = { + end: jest.fn(), +}; + describe('TaskClaiming', () => { + beforeEach(() => { + jest.clearAllMocks(); + jest + .spyOn(apm, 'startTransaction') + // eslint-disable-next-line @typescript-eslint/no-explicit-any + .mockImplementation(() => mockApmTrans as any); + }); + test(`should log when a certain task type is skipped due to having a zero concurency configuration`, () => { const definitions = new TaskTypeDictionary(mockLogger()); definitions.registerTaskDefinitions({ @@ -169,6 +182,12 @@ describe('TaskClaiming', () => { const results = await getAllAsPromise(taskClaiming.claimAvailableTasks(claimingOpts)); + expect(apm.startTransaction).toHaveBeenCalledWith( + 'markAvailableTasksAsClaimed', + 'taskManager markAvailableTasksAsClaimed' + ); + expect(mockApmTrans.end).toHaveBeenCalledWith('success'); + expect(store.updateByQuery.mock.calls[0][1]).toMatchObject({ max_docs: getCapacity(), }); @@ -187,6 +206,49 @@ describe('TaskClaiming', () => { })); } + test('makes calls to APM as expected when markAvailableTasksAsClaimed throws error', async () => { + const maxAttempts = _.random(2, 43); + const customMaxAttempts = _.random(44, 100); + + const definitions = new TaskTypeDictionary(mockLogger()); + definitions.registerTaskDefinitions({ + foo: { + title: 'foo', + createTaskRunner: jest.fn(), + }, + bar: { + title: 'bar', + maxAttempts: customMaxAttempts, + createTaskRunner: jest.fn(), + }, + }); + + const { taskClaiming, store } = initialiseTestClaiming({ + storeOpts: { + definitions, + }, + taskClaimingOpts: { + maxAttempts, + }, + }); + + store.updateByQuery.mockRejectedValue(new Error('Oh no')); + + await expect( + getAllAsPromise( + taskClaiming.claimAvailableTasks({ + claimOwnershipUntil: new Date(), + }) + ) + ).rejects.toMatchInlineSnapshot(`[Error: Oh no]`); + + expect(apm.startTransaction).toHaveBeenCalledWith( + 'markAvailableTasksAsClaimed', + 'taskManager markAvailableTasksAsClaimed' + ); + expect(mockApmTrans.end).toHaveBeenCalledWith('failure'); + }); + test('it filters claimed tasks down by supported types, maxAttempts, status, and runAt', async () => { const maxAttempts = _.random(2, 43); const customMaxAttempts = _.random(44, 100); @@ -1105,6 +1167,7 @@ if (doc['task.runAt'].size()!=0) { startedAt: null, retryAt: null, scheduledAt: new Date(), + traceparent: 'parent', }, { id: 'claimed-by-schedule', @@ -1121,6 +1184,7 @@ if (doc['task.runAt'].size()!=0) { startedAt: null, retryAt: null, scheduledAt: new Date(), + traceparent: 'newParent', }, { id: 'already-running', @@ -1137,6 +1201,7 @@ if (doc['task.runAt'].size()!=0) { startedAt: null, retryAt: null, scheduledAt: new Date(), + traceparent: '', }, ]; @@ -1222,6 +1287,7 @@ if (doc['task.runAt'].size()!=0) { startedAt: null, retryAt: null, scheduledAt: new Date(), + traceparent: 'parent', }) ) ); @@ -1277,6 +1343,7 @@ if (doc['task.runAt'].size()!=0) { startedAt: null, retryAt: null, scheduledAt: new Date(), + traceparent: '', }, ], // second cycle @@ -1296,6 +1363,7 @@ if (doc['task.runAt'].size()!=0) { startedAt: null, retryAt: null, scheduledAt: new Date(), + traceparent: '', }, ], ], @@ -1347,6 +1415,7 @@ if (doc['task.runAt'].size()!=0) { startedAt: null, retryAt: null, scheduledAt: new Date(), + traceparent: '', }), errorType: TaskClaimErrorType.CLAIMED_BY_ID_OUT_OF_CAPACITY, }) @@ -1393,6 +1462,7 @@ if (doc['task.runAt'].size()!=0) { startedAt: null, retryAt: null, scheduledAt: new Date(), + traceparent: 'newParent', }) ) ); @@ -1437,6 +1507,7 @@ if (doc['task.runAt'].size()!=0) { startedAt: null, retryAt: null, scheduledAt: new Date(), + traceparent: '', }), errorType: TaskClaimErrorType.CLAIMED_BY_ID_NOT_IN_CLAIMING_STATUS, }) @@ -1499,6 +1570,7 @@ function mockInstance(instance: Partial = {}) { status: 'idle', user: 'example', ownerId: null, + traceparent: '', }, instance ); diff --git a/x-pack/plugins/task_manager/server/task.ts b/x-pack/plugins/task_manager/server/task.ts index 28aac04f8fa0f5..3611c429122a9e 100644 --- a/x-pack/plugins/task_manager/server/task.ts +++ b/x-pack/plugins/task_manager/server/task.ts @@ -257,6 +257,9 @@ export interface TaskInstance { // eslint-disable-next-line @typescript-eslint/no-explicit-any state: Record; + /** + * The serialized traceparent string of the current APM transaction or span. + */ traceparent?: string; /** @@ -358,6 +361,11 @@ export interface ConcreteTaskInstance extends TaskInstance { * The random uuid of the Kibana instance which claimed ownership of the task last */ ownerId: string | null; + + /** + * The serialized traceparent string of the current APM transaction or span. + */ + traceparent: string; } export type SerializedConcreteTaskInstance = Omit< diff --git a/x-pack/plugins/task_manager/server/task_running/task_runner.test.ts b/x-pack/plugins/task_manager/server/task_running/task_runner.test.ts index 5a36d6affe686c..d5a86b532b0ae9 100644 --- a/x-pack/plugins/task_manager/server/task_running/task_runner.test.ts +++ b/x-pack/plugins/task_manager/server/task_running/task_runner.test.ts @@ -18,6 +18,7 @@ import { TaskDefinitionRegistry, TaskTypeDictionary } from '../task_type_diction import { mockLogger } from '../test_utils'; import { throwUnrecoverableError } from './errors'; import { taskStoreMock } from '../task_store.mock'; +import apm from 'elastic-apm-node'; const minutesFromNow = (mins: number): Date => secondsFromNow(mins * 60); @@ -32,8 +33,70 @@ afterAll(() => fakeTimer.restore()); describe('TaskManagerRunner', () => { const pendingStageSetup = (opts: TestOpts) => testOpts(TaskRunningStage.PENDING, opts); const readyToRunStageSetup = (opts: TestOpts) => testOpts(TaskRunningStage.READY_TO_RUN, opts); + const mockApmTrans = { + end: jest.fn(), + }; describe('Pending Stage', () => { + beforeEach(() => { + jest.clearAllMocks(); + jest + .spyOn(apm, 'startTransaction') + // eslint-disable-next-line @typescript-eslint/no-explicit-any + .mockImplementation(() => mockApmTrans as any); + }); + test('makes calls to APM as expected when task markedAsRunning is success', async () => { + const { runner } = await pendingStageSetup({ + instance: { + schedule: { + interval: '10m', + }, + }, + definitions: { + bar: { + title: 'Bar!', + createTaskRunner: () => ({ + run: async () => undefined, + }), + }, + }, + }); + await runner.markTaskAsRunning(); + expect(apm.startTransaction).toHaveBeenCalledWith( + 'taskManager', + 'taskManager markTaskAsRunning' + ); + expect(mockApmTrans.end).toHaveBeenCalledWith('success'); + }); + test('makes calls to APM as expected when task markedAsRunning fails', async () => { + const { runner, store } = await pendingStageSetup({ + instance: { + schedule: { + interval: '10m', + }, + }, + definitions: { + bar: { + title: 'Bar!', + createTaskRunner: () => ({ + run: async () => undefined, + }), + }, + }, + }); + store.update.mockRejectedValue( + SavedObjectsErrorHelpers.createGenericNotFoundError('type', 'id') + ); + await expect(runner.markTaskAsRunning()).rejects.toMatchInlineSnapshot( + `[Error: Saved object [type/id] not found]` + ); + // await runner.markTaskAsRunning(); + expect(apm.startTransaction).toHaveBeenCalledWith( + 'taskManager', + 'taskManager markTaskAsRunning' + ); + expect(mockApmTrans.end).toHaveBeenCalledWith('failure'); + }); test('provides details about the task that is running', async () => { const { runner } = await pendingStageSetup({ instance: { @@ -572,6 +635,55 @@ describe('TaskManagerRunner', () => { }); describe('Ready To Run Stage', () => { + beforeEach(() => { + jest.clearAllMocks(); + }); + test('makes calls to APM as expected when task runs successfully', async () => { + const { runner } = await readyToRunStageSetup({ + instance: { + params: { a: 'b' }, + state: { hey: 'there' }, + }, + definitions: { + bar: { + title: 'Bar!', + createTaskRunner: () => ({ + async run() { + return { state: {} }; + }, + }), + }, + }, + }); + await runner.run(); + expect(apm.startTransaction).toHaveBeenCalledWith('bar', 'taskManager run', { + childOf: 'apmTraceparent', + }); + expect(mockApmTrans.end).toHaveBeenCalledWith('success'); + }); + test('makes calls to APM as expected when task fails', async () => { + const { runner } = await readyToRunStageSetup({ + instance: { + params: { a: 'b' }, + state: { hey: 'there' }, + }, + definitions: { + bar: { + title: 'Bar!', + createTaskRunner: () => ({ + async run() { + throw new Error('rar'); + }, + }), + }, + }, + }); + await runner.run(); + expect(apm.startTransaction).toHaveBeenCalledWith('bar', 'taskManager run', { + childOf: 'apmTraceparent', + }); + expect(mockApmTrans.end).toHaveBeenCalledWith('failure'); + }); test('queues a reattempt if the task fails', async () => { const initialAttempts = _.random(0, 2); const id = Date.now().toString(); @@ -1275,6 +1387,7 @@ describe('TaskManagerRunner', () => { status: 'idle', user: 'example', ownerId: null, + traceparent: 'apmTraceparent', }, instance ); diff --git a/x-pack/plugins/task_manager/server/task_scheduling.test.ts b/x-pack/plugins/task_manager/server/task_scheduling.test.ts index b142f2091291ed..3445bd18de1025 100644 --- a/x-pack/plugins/task_manager/server/task_scheduling.test.ts +++ b/x-pack/plugins/task_manager/server/task_scheduling.test.ts @@ -27,6 +27,10 @@ import { TaskRunResult } from './task_running'; import { mockLogger } from './test_utils'; import { TaskTypeDictionary } from './task_type_dictionary'; +jest.mock('elastic-apm-node', () => ({ + currentTraceparent: 'parent', +})); + describe('TaskScheduling', () => { const mockTaskStore = taskStoreMock.create({}); const mockTaskManager = taskPollingLifecycleMock.create({}); @@ -60,6 +64,12 @@ describe('TaskScheduling', () => { }; await taskScheduling.schedule(task); expect(mockTaskStore.schedule).toHaveBeenCalled(); + expect(mockTaskStore.schedule).toHaveBeenCalledWith({ + ...task, + id: undefined, + schedule: undefined, + traceparent: 'parent', + }); }); test('allows scheduling existing tasks that may have already been scheduled', async () => { @@ -420,6 +430,7 @@ function mockTask(overrides: Partial = {}): ConcreteTaskIn startedAt: null, retryAt: null, scheduledAt: new Date(), + traceparent: 'taskTraceparent', ...overrides, }; } diff --git a/x-pack/plugins/task_manager/server/task_store.test.ts b/x-pack/plugins/task_manager/server/task_store.test.ts index a44bddcdb82014..2d2bd81af96e5c 100644 --- a/x-pack/plugins/task_manager/server/task_store.test.ts +++ b/x-pack/plugins/task_manager/server/task_store.test.ts @@ -94,6 +94,7 @@ describe('TaskStore', () => { params: { hello: 'world' }, state: { foo: 'bar' }, taskType: 'report', + traceparent: 'apmTraceparent', }; const result = await testSchedule(task); @@ -112,6 +113,7 @@ describe('TaskStore', () => { status: 'idle', taskType: 'report', user: undefined, + traceparent: 'apmTraceparent', }, { id: 'id', @@ -134,6 +136,7 @@ describe('TaskStore', () => { taskType: 'report', user: undefined, version: '123', + traceparent: 'apmTraceparent', }); }); @@ -285,6 +288,7 @@ describe('TaskStore', () => { status: 'idle' as TaskStatus, version: '123', ownerId: null, + traceparent: 'myTraceparent', }; savedObjectsClient.update.mockImplementation( @@ -318,6 +322,7 @@ describe('TaskStore', () => { taskType: task.taskType, user: undefined, ownerId: null, + traceparent: 'myTraceparent', }, { version: '123', refresh: false } ); @@ -347,6 +352,7 @@ describe('TaskStore', () => { status: 'idle' as TaskStatus, version: '123', ownerId: null, + traceparent: '', }; const firstErrorPromise = store.errors$.pipe(first()).toPromise(); @@ -384,6 +390,7 @@ describe('TaskStore', () => { status: 'idle' as TaskStatus, version: '123', ownerId: null, + traceparent: '', }; const firstErrorPromise = store.errors$.pipe(first()).toPromise(); @@ -500,6 +507,7 @@ describe('TaskStore', () => { status: status as TaskStatus, version: '123', ownerId: null, + traceparent: 'myTraceparent', }; savedObjectsClient.get.mockImplementation(async (type: string, objectId: string) => ({ diff --git a/x-pack/plugins/task_manager/server/task_store.ts b/x-pack/plugins/task_manager/server/task_store.ts index 0eeccd0af75f77..69bafdba2d3f91 100644 --- a/x-pack/plugins/task_manager/server/task_store.ts +++ b/x-pack/plugins/task_manager/server/task_store.ts @@ -421,6 +421,7 @@ function taskInstanceToAttributes(doc: TaskInstance): SerializedConcreteTaskInst retryAt: (doc.retryAt && doc.retryAt.toISOString()) || null, runAt: (doc.runAt || new Date()).toISOString(), status: (doc as ConcreteTaskInstance).status || 'idle', + traceparent: (doc as ConcreteTaskInstance).traceparent || '', } as SerializedConcreteTaskInstance; } @@ -437,6 +438,7 @@ export function savedObjectToConcreteTaskInstance( retryAt: savedObject.attributes.retryAt ? new Date(savedObject.attributes.retryAt) : null, state: parseJSONField(savedObject.attributes.state, 'state', savedObject.id), params: parseJSONField(savedObject.attributes.params, 'params', savedObject.id), + traceparent: savedObject.attributes.traceparent, }; } From a01134c683d0aa7c4d26b8ea30d6dbee5083e8e7 Mon Sep 17 00:00:00 2001 From: Ying Mao Date: Tue, 25 May 2021 14:50:26 -0400 Subject: [PATCH 7/7] Reverting unnecessary changes --- .../server/cleanup_failed_executions/task_runner.test.ts | 1 - .../plugins/actions/server/lib/task_runner_factory.test.ts | 1 - .../plugins/task_manager/server/buffered_task_store.test.ts | 1 - x-pack/plugins/task_manager/server/lib/fill_pool.test.ts | 1 - .../server/monitoring/task_run_statistics.test.ts | 1 - x-pack/plugins/task_manager/server/task.ts | 5 ----- x-pack/plugins/task_manager/server/task_store.ts | 2 -- 7 files changed, 12 deletions(-) diff --git a/x-pack/plugins/actions/server/cleanup_failed_executions/task_runner.test.ts b/x-pack/plugins/actions/server/cleanup_failed_executions/task_runner.test.ts index 4062869f373f37..d465e532b0284f 100644 --- a/x-pack/plugins/actions/server/cleanup_failed_executions/task_runner.test.ts +++ b/x-pack/plugins/actions/server/cleanup_failed_executions/task_runner.test.ts @@ -53,7 +53,6 @@ describe('taskRunner', () => { ownerId: '234', taskType: 'foo', params: {}, - traceparent: '', }; beforeEach(() => { diff --git a/x-pack/plugins/actions/server/lib/task_runner_factory.test.ts b/x-pack/plugins/actions/server/lib/task_runner_factory.test.ts index 67afd806646ca2..229324c1f0df38 100644 --- a/x-pack/plugins/actions/server/lib/task_runner_factory.test.ts +++ b/x-pack/plugins/actions/server/lib/task_runner_factory.test.ts @@ -44,7 +44,6 @@ beforeAll(() => { actionTaskParamsId: '3', }, taskType: 'actions:1', - traceparent: '', }; taskRunnerFactory = new TaskRunnerFactory(mockedActionExecutor); mockedActionExecutor.initialize(actionExecutorInitializerParams); diff --git a/x-pack/plugins/task_manager/server/buffered_task_store.test.ts b/x-pack/plugins/task_manager/server/buffered_task_store.test.ts index 7c1e6f24127c21..45607713a31287 100644 --- a/x-pack/plugins/task_manager/server/buffered_task_store.test.ts +++ b/x-pack/plugins/task_manager/server/buffered_task_store.test.ts @@ -110,6 +110,5 @@ function mockTask() { user: undefined, version: '123', ownerId: '123', - traceparent: '', }; } diff --git a/x-pack/plugins/task_manager/server/lib/fill_pool.test.ts b/x-pack/plugins/task_manager/server/lib/fill_pool.test.ts index 205e3312fbd14e..8e0396a453b3d9 100644 --- a/x-pack/plugins/task_manager/server/lib/fill_pool.test.ts +++ b/x-pack/plugins/task_manager/server/lib/fill_pool.test.ts @@ -54,7 +54,6 @@ describe('fillPool', () => { taskType: '', params: {}, ownerId: null, - traceparent: '', })); test('fills task pool with all claimed tasks until fetchAvailableTasks stream closes', async () => { diff --git a/x-pack/plugins/task_manager/server/monitoring/task_run_statistics.test.ts b/x-pack/plugins/task_manager/server/monitoring/task_run_statistics.test.ts index d47bd142856062..7040d5acd4eaf3 100644 --- a/x-pack/plugins/task_manager/server/monitoring/task_run_statistics.test.ts +++ b/x-pack/plugins/task_manager/server/monitoring/task_run_statistics.test.ts @@ -591,7 +591,6 @@ const mockTaskInstance = (overrides: Partial = {}): Concre alertId: '1', }, ownerId: null, - traceparent: '', ...overrides, }); diff --git a/x-pack/plugins/task_manager/server/task.ts b/x-pack/plugins/task_manager/server/task.ts index 3611c429122a9e..8f515e1951ef5f 100644 --- a/x-pack/plugins/task_manager/server/task.ts +++ b/x-pack/plugins/task_manager/server/task.ts @@ -361,11 +361,6 @@ export interface ConcreteTaskInstance extends TaskInstance { * The random uuid of the Kibana instance which claimed ownership of the task last */ ownerId: string | null; - - /** - * The serialized traceparent string of the current APM transaction or span. - */ - traceparent: string; } export type SerializedConcreteTaskInstance = Omit< diff --git a/x-pack/plugins/task_manager/server/task_store.ts b/x-pack/plugins/task_manager/server/task_store.ts index 69bafdba2d3f91..0eeccd0af75f77 100644 --- a/x-pack/plugins/task_manager/server/task_store.ts +++ b/x-pack/plugins/task_manager/server/task_store.ts @@ -421,7 +421,6 @@ function taskInstanceToAttributes(doc: TaskInstance): SerializedConcreteTaskInst retryAt: (doc.retryAt && doc.retryAt.toISOString()) || null, runAt: (doc.runAt || new Date()).toISOString(), status: (doc as ConcreteTaskInstance).status || 'idle', - traceparent: (doc as ConcreteTaskInstance).traceparent || '', } as SerializedConcreteTaskInstance; } @@ -438,7 +437,6 @@ export function savedObjectToConcreteTaskInstance( retryAt: savedObject.attributes.retryAt ? new Date(savedObject.attributes.retryAt) : null, state: parseJSONField(savedObject.attributes.state, 'state', savedObject.id), params: parseJSONField(savedObject.attributes.params, 'params', savedObject.id), - traceparent: savedObject.attributes.traceparent, }; }