[Composite SLO] Instrument background task with APM transaction spans and labels (elastic#269762)

## Summary

<img width="1885" height="955" alt="image"
src="https://github.com/user-attachments/assets/31b15756-6822-44bd-87a5-7e39734d333f"
/>


- Instrument `computeAndPersistCompositeSummaries` with
`@kbn/apm-utils`: **`withSpan`** for decode/group, member SO fetch,
member summary compute, and bulk write (children of Task Manager’s
existing **`task-run`** transaction—no new top-level transaction).
- **`addTransactionLabels`** on each run for outcome, counters,
duration, pages fetched, and max-limit flag; same for early
**`runTask`** exits (`task_not_started`, `outdated_task_version`).
- Unit tests with mocked `@kbn/apm-utils`.

Closes elastic#264015.

## Test plan

- [x] `node scripts/jest` —
`compute_and_persist_composite_summaries.test.ts`,
`composite_slo_summary_task.test.ts`
- [ ] Optional: Kibana with `elastic.apm.active: true` and confirm spans
+ labels on one task run

kibana.dev.yml:
```Yaml
xpack.slo.experimental.compositeSlo.enabled: true
xpack.slo.compositeSloSummaryTaskEnabled: true

# APM https://kibana-cloud-apm.elastic.dev/app/apm/services?comparisonEnabled=true&rangeFrom=now-15m&rangeTo=now&offset=1d
elastic.apm.active: true
elastic.apm.transactionSampleRate: 1
elastic.apm.environment: <YOUR_USERNAME>
```

Author: miguelmartin-elastic

x-pack/solutions/observability/plugins/slo/server/services/tasks/composite_slo_summary_task/composite_slo_summary_task.test.ts

@@ -0,0 +1,163 @@
+/*
+ * 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 { addTransactionLabels } from '@kbn/apm-utils';
+import type { CoreSetup, LoggerFactory } from '@kbn/core/server';
+import {
+  coreMock,
+  elasticsearchServiceMock,
+  loggingSystemMock,
+  savedObjectsRepositoryMock,
+} from '@kbn/core/server/mocks';
+import type { ConcreteTaskInstance } from '@kbn/task-manager-plugin/server';
+import { TaskStatus } from '@kbn/task-manager-plugin/server';
+import { taskManagerMock } from '@kbn/task-manager-plugin/server/mocks';
+import type { SLOConfig, SLOPluginStartDependencies } from '../../../types';
+import {
+  CompositeSloSummaryTask,
+  getCompositeSloSummaryTaskId,
+  TYPE,
+} from './composite_slo_summary_task';
+import { computeAndPersistCompositeSummaries } from './compute_and_persist_composite_summaries';
+import { COMPOSITE_SLO_SUMMARY_TASK_SKIP_REASON } from './constants';
+
+jest.mock('@kbn/apm-utils', () => ({
+  addTransactionLabels: jest.fn(),
+}));
+
+jest.mock('./compute_and_persist_composite_summaries', () => ({
+  computeAndPersistCompositeSummaries: jest.fn().mockResolvedValue(undefined),
+}));
+
+const addTransactionLabelsMock = addTransactionLabels as jest.MockedFunction<
+  typeof addTransactionLabels
+>;
+const mockPersist = computeAndPersistCompositeSummaries as jest.MockedFunction<
+  typeof computeAndPersistCompositeSummaries
+>;
+
+function createConcreteTaskInstanceStub(id: string): ConcreteTaskInstance {
+  const now = new Date('2024-01-01T00:00:00.000Z');
+  return {
+    id,
+    taskType: TYPE,
+    params: {},
+    state: {},
+    scheduledAt: now,
+    attempts: 0,
+    status: TaskStatus.Running,
+    runAt: now,
+    startedAt: now,
+    retryAt: null,
+    ownerId: null,
+  };
+}
+
+function createStartPlugins(): SLOPluginStartDependencies {
+  return {
+    licensing: {
+      getLicense: jest.fn().mockResolvedValue({ hasAtLeast: jest.fn().mockReturnValue(true) }),
+    },
+    taskManager: taskManagerMock.createStart(),
+  } as unknown as SLOPluginStartDependencies;
+}
+
+describe('CompositeSloSummaryTask', () => {
+  let coreSetup: ReturnType<typeof coreMock.createSetup>;
+  let task: CompositeSloSummaryTask;
+
+  const baseConfig = {
+    sloOrphanSummaryCleanUpTaskEnabled: true,
+    tempSummaryCleanupTaskEnabled: true,
+    healthScanTaskEnabled: true,
+    staleInstancesCleanupTaskEnabled: false,
+    compositeSloSummaryTaskEnabled: true,
+    enabled: true,
+    experimental: {
+      ruleFormV2: { enabled: false },
+      compositeSlo: { enabled: true },
+    },
+  } satisfies SLOConfig;
+
+  function createTask(): CompositeSloSummaryTask {
+    coreSetup = coreMock.createSetup();
+    coreSetup.getStartServices.mockResolvedValue([
+      {
+        elasticsearch: {
+          client: {
+            asInternalUser: elasticsearchServiceMock.createClusterClient().asInternalUser,
+          },
+        },
+        savedObjects: {
+          createInternalRepository: jest.fn().mockReturnValue(savedObjectsRepositoryMock.create()),
+        },
+      } as never,
+      {} as never,
+      {} as never,
+    ]);
+
+    return new CompositeSloSummaryTask({
+      core: coreSetup as CoreSetup,
+      config: baseConfig,
+      taskManager: taskManagerMock.createSetup(),
+      logFactory: loggingSystemMock.create() as unknown as LoggerFactory,
+    });
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockPersist.mockResolvedValue(undefined);
+    task = createTask();
+  });
+
+  describe('runTask APM labels', () => {
+    it('labels skipped when task was never started', async () => {
+      await task.runTask(
+        createConcreteTaskInstanceStub(getCompositeSloSummaryTaskId()),
+        coreSetup as CoreSetup,
+        new AbortController()
+      );
+
+      expect(addTransactionLabelsMock).toHaveBeenCalledWith({
+        plugin: 'slo',
+        composite_slo_summary_run_outcome: 'skipped',
+        composite_slo_summary_skip_reason: COMPOSITE_SLO_SUMMARY_TASK_SKIP_REASON.TASK_NOT_STARTED,
+      });
+      expect(mockPersist).not.toHaveBeenCalled();
+    });
+
+    it('labels skipped outdated_task_version when task instance id does not match', async () => {
+      await task.start(createStartPlugins());
+
+      await task.runTask(
+        createConcreteTaskInstanceStub('stale-task-instance-id'),
+        coreSetup as CoreSetup,
+        new AbortController()
+      );
+
+      expect(addTransactionLabelsMock).toHaveBeenCalledWith({
+        plugin: 'slo',
+        composite_slo_summary_run_outcome: 'skipped',
+        composite_slo_summary_skip_reason:
+          COMPOSITE_SLO_SUMMARY_TASK_SKIP_REASON.OUTDATED_TASK_VERSION,
+      });
+      expect(mockPersist).not.toHaveBeenCalled();
+    });
+
+    it('runs computeAndPersistCompositeSummaries when started and id matches', async () => {
+      await task.start(createStartPlugins());
+
+      await task.runTask(
+        createConcreteTaskInstanceStub(getCompositeSloSummaryTaskId()),
+        coreSetup as CoreSetup,
+        new AbortController()
+      );
+
+      expect(mockPersist).toHaveBeenCalledTimes(1);
+    });
+  });
+});

x-pack/solutions/observability/plugins/slo/server/services/tasks/composite_slo_summary_task/composite_slo_summary_task.ts

@@ -11,6 +11,7 @@ import {
   type Logger,
   type LoggerFactory,
 } from '@kbn/core/server';
+import { addTransactionLabels } from '@kbn/apm-utils';
 import type {
   ConcreteTaskInstance,
   TaskManagerSetupContract,
@@ -19,6 +20,7 @@ import { getDeleteTaskRunResult } from '@kbn/task-manager-plugin/server/task';
 import type { SLOConfig, SLOPluginStartDependencies } from '../../../types';
 import { SO_SLO_COMPOSITE_TYPE } from '../../../saved_objects/slo_composite';
 import { computeAndPersistCompositeSummaries } from './compute_and_persist_composite_summaries';
+import { COMPOSITE_SLO_SUMMARY_TASK_SKIP_REASON } from './constants';
 
 export const TYPE = 'slo:composite-slo-summary-task';
 
@@ -118,13 +120,24 @@ export class CompositeSloSummaryTask {
   ): Promise<{ state: Record<string, unknown> } | void> {
     if (!this.wasStarted) {
       this.logger.debug('runTask Aborted. Task not started yet');
+      addTransactionLabels({
+        plugin: 'slo',
+        composite_slo_summary_run_outcome: 'skipped',
+        composite_slo_summary_skip_reason: COMPOSITE_SLO_SUMMARY_TASK_SKIP_REASON.TASK_NOT_STARTED,
+      });
       return;
     }
 
     if (taskInstance.id !== this.taskId) {
       this.logger.debug(
         `Outdated task version: Got [${taskInstance.id}], current version is [${this.taskId}]`
       );
+      addTransactionLabels({
+        plugin: 'slo',
+        composite_slo_summary_run_outcome: 'skipped',
+        composite_slo_summary_skip_reason:
+          COMPOSITE_SLO_SUMMARY_TASK_SKIP_REASON.OUTDATED_TASK_VERSION,
+      });
       return getDeleteTaskRunResult();
     }