[7.x] [Security Solution][Telemetry] Refactoring security telemetry task code (#114095)

x-pack/plugins/security_solution/server/lib/telemetry/__mocks__/index.ts

@@ -0,0 +1,102 @@
+/*
+ * 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 { ConcreteTaskInstance, TaskStatus } from '../../../../../task_manager/server';
+import { TelemetryEventsSender } from '../sender';
+import { TelemetryReceiver } from '../receiver';
+import { SecurityTelemetryTaskConfig } from '../task';
+import { PackagePolicy } from '../../../../../fleet/common/types/models/package_policy';
+
+/**
+ * Creates a mocked Telemetry Events Sender
+ */
+export const createMockTelemetryEventsSender = (
+  enableTelemetry?: boolean
+): jest.Mocked<TelemetryEventsSender> => {
+  return {
+    setup: jest.fn(),
+    start: jest.fn(),
+    stop: jest.fn(),
+    fetchTelemetryUrl: jest.fn(),
+    queueTelemetryEvents: jest.fn(),
+    processEvents: jest.fn(),
+    isTelemetryOptedIn: jest.fn().mockReturnValue(enableTelemetry ?? jest.fn()),
+    sendIfDue: jest.fn(),
+    sendEvents: jest.fn(),
+  } as unknown as jest.Mocked<TelemetryEventsSender>;
+};
+
+export const createMockTelemetryReceiver = (
+  diagnosticsAlert?: unknown
+): jest.Mocked<TelemetryReceiver> => {
+  return {
+    start: jest.fn(),
+    fetchClusterInfo: jest.fn(),
+    fetchLicenseInfo: jest.fn(),
+    copyLicenseFields: jest.fn(),
+    fetchFleetAgents: jest.fn(),
+    fetchDiagnosticAlerts: jest.fn().mockReturnValue(diagnosticsAlert ?? jest.fn()),
+    fetchEndpointMetrics: jest.fn(),
+    fetchEndpointPolicyResponses: jest.fn(),
+    fetchTrustedApplications: jest.fn(),
+    fetchEndpointList: jest.fn(),
+    fetchDetectionRules: jest.fn().mockReturnValue({ body: null }),
+  } as unknown as jest.Mocked<TelemetryReceiver>;
+};
+
+/**
+ * Creates a mocked package policy
+ */
+export const createMockPackagePolicy = (): jest.Mocked<PackagePolicy> => {
+  return {
+    id: jest.fn(),
+    inputs: jest.fn(),
+    version: jest.fn(),
+    revision: jest.fn(),
+    updated_at: jest.fn(),
+    updated_by: jest.fn(),
+    created_at: jest.fn(),
+    created_by: jest.fn(),
+  } as unknown as jest.Mocked<PackagePolicy>;
+};
+
+/**
+ * Creates a mocked Security Telemetry Task Config
+ */
+export const createMockSecurityTelemetryTask = (
+  testType?: string,
+  testLastTimestamp?: string
+): jest.Mocked<SecurityTelemetryTaskConfig> => {
+  return {
+    type: testType,
+    title: 'test title',
+    interval: '0m',
+    timeout: '0m',
+    version: '0.0.0',
+    getLastExecutionTime: jest.fn().mockReturnValue(testLastTimestamp ?? jest.fn()),
+    runTask: jest.fn(),
+  } as unknown as jest.Mocked<SecurityTelemetryTaskConfig>;
+};
+
+/**
+ * Creates a mocked Task Instance
+ */
+export const createMockTaskInstance = (testId: string, testType: string): ConcreteTaskInstance => {
+  return {
+    id: testId,
+    runAt: new Date(),
+    attempts: 0,
+    ownerId: '',
+    status: TaskStatus.Running,
+    startedAt: new Date(),
+    scheduledAt: new Date(),
+    retryAt: new Date(),
+    params: {},
+    state: {},
+    taskType: testType,
+  } as ConcreteTaskInstance;
+};

x-pack/plugins/security_solution/server/lib/telemetry/constants.ts

@@ -7,6 +7,12 @@
 
 export const TELEMETRY_MAX_BUFFER_SIZE = 100;
 
+export const MAX_SECURITY_LIST_TELEMETRY_BATCH = 100;
+
+export const MAX_ENDPOINT_TELEMETRY_BATCH = 1_000;
+
+export const MAX_DETECTION_RULE_TELEMETRY_BATCH = 1_000;
+
 export const TELEMETRY_CHANNEL_LISTS = 'security-lists-v2';
 
 export const TELEMETRY_CHANNEL_ENDPOINT_META = 'endpoint-metadata';

x-pack/plugins/security_solution/server/lib/telemetry/helpers.test.ts

@@ -6,7 +6,7 @@
  */
 
 import moment from 'moment';
-import { createMockPackagePolicy } from './mocks';
+import { createMockPackagePolicy } from './__mocks__';
 import {
   LIST_DETECTION_RULE_EXCEPTION,
   LIST_ENDPOINT_EXCEPTION,

x-pack/plugins/security_solution/server/lib/telemetry/sender.ts

@@ -18,10 +18,11 @@ import {
 } from '../../../../task_manager/server';
 import { TelemetryReceiver } from './receiver';
 import { allowlistEventFields, copyAllowlistedFields } from './filters';
-import { DiagnosticTask, EndpointTask, ExceptionListsTask, DetectionRulesTask } from './tasks';
+import { createTelemetryTaskConfigs } from './tasks';
 import { createUsageCounterLabel } from './helpers';
 import { TelemetryEvent } from './types';
 import { TELEMETRY_MAX_BUFFER_SIZE } from './constants';
+import { SecurityTelemetryTask, SecurityTelemetryTaskConfig } from './task';
 
 const usageLabelPrefix: string[] = ['security_telemetry', 'sender'];
 
@@ -39,10 +40,7 @@ export class TelemetryEventsSender {
   private isOptedIn?: boolean = true; // Assume true until the first check
 
   private telemetryUsageCounter?: UsageCounter;
-  private diagnosticTask?: DiagnosticTask;
-  private endpointTask?: EndpointTask;
-  private exceptionListsTask?: ExceptionListsTask;
-  private detectionRulesTask?: DetectionRulesTask;
+  private telemetryTasks?: SecurityTelemetryTask[];
 
   constructor(logger: Logger) {
     this.logger = logger.get('telemetry_events');
@@ -58,19 +56,12 @@ export class TelemetryEventsSender {
     this.telemetryUsageCounter = telemetryUsageCounter;
 
     if (taskManager) {
-      this.diagnosticTask = new DiagnosticTask(this.logger, taskManager, this, telemetryReceiver);
-      this.endpointTask = new EndpointTask(this.logger, taskManager, this, telemetryReceiver);
-      this.detectionRulesTask = new DetectionRulesTask(
-        this.logger,
-        taskManager,
-        this,
-        telemetryReceiver
-      );
-      this.exceptionListsTask = new ExceptionListsTask(
-        this.logger,
-        taskManager,
-        this,
-        telemetryReceiver
+      this.telemetryTasks = createTelemetryTaskConfigs().map(
+        (config: SecurityTelemetryTaskConfig) => {
+          const task = new SecurityTelemetryTask(config, this.logger, this, telemetryReceiver);
+          task.register(taskManager);
+          return task;
+        }
       );
     }
   }
@@ -83,12 +74,9 @@ export class TelemetryEventsSender {
     this.telemetryStart = telemetryStart;
     this.receiver = receiver;
 
-    if (taskManager && this.diagnosticTask && this.endpointTask && this.exceptionListsTask) {
-      this.logger.debug(`starting security telemetry tasks`);
-      this.diagnosticTask.start(taskManager);
-      this.endpointTask.start(taskManager);
-      this.detectionRulesTask?.start(taskManager);
-      this.exceptionListsTask?.start(taskManager);
+    if (taskManager && this.telemetryTasks) {
+      this.logger.debug(`Starting security telemetry tasks`);
+      this.telemetryTasks.forEach((task) => task.start(taskManager));
     }
 
     this.logger.debug(`Starting local task`);