@robota-sdk/agent-plugin 3.0.0-beta.64

package/src/execution-analytics/__tests__/execution-analytics-plugin.test.ts

@@ -0,0 +1,224 @@
+import { randomUUID } from 'node:crypto';
+import { describe, it, expect } from 'vitest';
+import { ExecutionAnalyticsPlugin } from '../execution-analytics-plugin';
+import type { TUniversalMessage } from '@robota-sdk/agent-core';
+
+function userMsg(content: string): TUniversalMessage {
+  return {
+    id: randomUUID(),
+    role: 'user',
+    content,
+    state: 'complete',
+    timestamp: new Date(),
+  };
+}
+
+function assistantMsg(content: string): TUniversalMessage {
+  return {
+    id: randomUUID(),
+    role: 'assistant',
+    content,
+    state: 'complete',
+    timestamp: new Date(),
+  };
+}
+
+describe('ExecutionAnalyticsPlugin', () => {
+  describe('constructor', () => {
+    it('initializes with default options', () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+      expect(plugin.name).toBe('ExecutionAnalyticsPlugin');
+      expect(plugin.version).toBe('1.0.0');
+    });
+
+    it('initializes with custom options', () => {
+      const plugin = new ExecutionAnalyticsPlugin({
+        maxEntries: 500,
+        performanceThreshold: 2000,
+        trackErrors: false,
+      });
+      expect(plugin.getPluginStats().totalRecorded).toBe(0);
+    });
+  });
+
+  describe('run tracking', () => {
+    it('tracks beforeRun and afterRun lifecycle', async () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+
+      await plugin.beforeRun('hello world');
+      expect(plugin.getActiveExecutions()).toHaveLength(1);
+      expect(plugin.getActiveExecutions()[0].operation).toBe('run');
+
+      await plugin.afterRun('hello world', 'response text');
+      expect(plugin.getActiveExecutions()).toHaveLength(0);
+
+      const stats = plugin.getExecutionStats('run');
+      expect(stats).toHaveLength(1);
+      expect(stats[0].success).toBe(true);
+      expect(stats[0].operation).toBe('run');
+      expect(stats[0].duration).toBeGreaterThanOrEqual(0);
+    });
+
+    it('records metadata with input/output lengths', async () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+
+      await plugin.beforeRun('input text');
+      await plugin.afterRun('input text', 'output text');
+
+      const stats = plugin.getExecutionStats('run');
+      expect(stats[0].metadata?.inputLength).toBe(10);
+      expect(stats[0].metadata?.responseLength).toBe(11);
+    });
+  });
+
+  describe('provider call tracking', () => {
+    it('tracks provider call lifecycle', async () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+      const messages = [userMsg('what is 1+1?')];
+      const response = assistantMsg('2');
+
+      await plugin.beforeProviderCall(messages);
+      expect(plugin.getActiveExecutions()).toHaveLength(1);
+
+      await plugin.afterProviderCall(messages, response);
+      expect(plugin.getActiveExecutions()).toHaveLength(0);
+
+      const stats = plugin.getExecutionStats('provider-call');
+      expect(stats).toHaveLength(1);
+      expect(stats[0].success).toBe(true);
+    });
+  });
+
+  describe('tool call tracking', () => {
+    it('tracks tool call lifecycle', async () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+
+      await plugin.beforeToolCall('calculator', { a: 1, b: 2 });
+      await plugin.afterToolCall('calculator', { a: 1, b: 2 }, { success: true, result: '3' });
+
+      const stats = plugin.getExecutionStats('tool-call');
+      expect(stats).toHaveLength(1);
+      expect(stats[0].success).toBe(true);
+      expect(stats[0].metadata?.toolName).toBe('calculator');
+    });
+
+    it('tracks tool call with error', async () => {
+      const plugin = new ExecutionAnalyticsPlugin({ trackErrors: true });
+
+      await plugin.beforeToolCall('failing-tool', {});
+      await plugin.afterToolCall('failing-tool', {}, { success: false, error: 'tool failed' });
+
+      const stats = plugin.getExecutionStats('tool-call');
+      expect(stats).toHaveLength(1);
+      expect(stats[0].success).toBe(false);
+      expect(stats[0].error?.type).toBe('ToolExecutionError');
+    });
+  });
+
+  describe('error tracking', () => {
+    it('records error for active execution', async () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+
+      await plugin.beforeRun('test input');
+      await plugin.onError(new Error('something went wrong'));
+
+      const stats = plugin.getExecutionStats();
+      expect(stats).toHaveLength(1);
+      expect(stats[0].success).toBe(false);
+      expect(stats[0].error?.message).toBe('something went wrong');
+    });
+
+    it('handles error when no active execution exists', async () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+      await expect(plugin.onError(new Error('orphan error'))).resolves.not.toThrow();
+    });
+  });
+
+  describe('getAggregatedStats', () => {
+    it('returns empty stats when no executions recorded', () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+      const aggregated = plugin.getAggregatedStats();
+
+      expect(aggregated.totalExecutions).toBe(0);
+      expect(aggregated.successRate).toBe(0);
+      expect(aggregated.averageDuration).toBe(0);
+    });
+
+    it('aggregates across multiple operations', async () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+
+      await plugin.beforeRun('input1');
+      await plugin.afterRun('input1', 'output1');
+
+      await plugin.beforeRun('input2');
+      await plugin.afterRun('input2', 'output2');
+
+      await plugin.beforeToolCall('tool1', {});
+      await plugin.afterToolCall('tool1', {}, { success: false, error: 'fail' });
+
+      const aggregated = plugin.getAggregatedStats();
+      expect(aggregated.totalExecutions).toBe(3);
+      expect(aggregated.successfulExecutions).toBe(2);
+      expect(aggregated.failedExecutions).toBe(1);
+      expect(aggregated.operationStats['run']?.count).toBe(2);
+      expect(aggregated.operationStats['tool-call']?.count).toBe(1);
+    });
+  });
+
+  describe('max entries rotation', () => {
+    it('maintains max entries limit by removing oldest', async () => {
+      const plugin = new ExecutionAnalyticsPlugin({ maxEntries: 3 });
+
+      for (let i = 0; i < 5; i++) {
+        await plugin.beforeRun(`input-${i}`);
+        await plugin.afterRun(`input-${i}`, `output-${i}`);
+      }
+
+      const stats = plugin.getExecutionStats();
+      expect(stats).toHaveLength(3);
+    });
+  });
+
+  describe('clearStats', () => {
+    it('clears all execution data', async () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+
+      await plugin.beforeRun('input');
+      await plugin.afterRun('input', 'output');
+
+      plugin.clearStats();
+
+      expect(plugin.getExecutionStats()).toHaveLength(0);
+      expect(plugin.getActiveExecutions()).toHaveLength(0);
+      expect(plugin.getPluginStats().totalRecorded).toBe(0);
+    });
+  });
+
+  describe('getPluginStats', () => {
+    it('reports memory usage and record count', async () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+
+      await plugin.beforeRun('test');
+      await plugin.afterRun('test', 'response');
+
+      const pluginStats = plugin.getPluginStats();
+      expect(pluginStats.totalRecorded).toBe(1);
+      expect(pluginStats.activeExecutions).toBe(0);
+      expect(pluginStats.oldestRecord).toBeDefined();
+      expect(pluginStats.newestRecord).toBeDefined();
+    });
+  });
+
+  describe('destroy', () => {
+    it('clears all data on destroy', async () => {
+      const plugin = new ExecutionAnalyticsPlugin();
+
+      await plugin.beforeRun('test');
+      await plugin.afterRun('test', 'response');
+
+      await plugin.destroy();
+
+      expect(plugin.getExecutionStats()).toHaveLength(0);
+    });
+  });
+});

package/src/execution-analytics/analytics-aggregation.ts

@@ -0,0 +1,88 @@
+/**
+ * Stats aggregation logic for ExecutionAnalyticsPlugin.
+ *
+ * Extracted from execution-analytics-plugin.ts to keep each file under 300 lines.
+ * @internal
+ */
+import type { IExecutionStats, IAggregatedExecutionStats } from './types';
+
+/** Compute aggregated analytics across recorded executions. @internal */
+export function aggregateExecutionStats(
+  stats: IExecutionStats[],
+  timeRange?: { start: Date; end: Date },
+): IAggregatedExecutionStats {
+  if (stats.length === 0) {
+    return {
+      totalExecutions: 0,
+      successfulExecutions: 0,
+      failedExecutions: 0,
+      successRate: 0,
+      averageDuration: 0,
+      totalDuration: 0,
+      operationStats: {},
+      errorStats: {},
+      timeRange: timeRange || { start: new Date(), end: new Date() },
+    };
+  }
+
+  const totalExecutions = stats.length;
+  const successfulExecutions = stats.filter((s) => s.success).length;
+  const failedExecutions = totalExecutions - successfulExecutions;
+  const totalDuration = stats.reduce((sum, s) => sum + s.duration, 0);
+  const averageDuration = totalDuration / totalExecutions;
+
+  const operationStats: Record<
+    string,
+    {
+      count: number;
+      successCount: number;
+      failureCount: number;
+      totalDuration: number;
+      averageDuration: number;
+    }
+  > = {};
+
+  for (const stat of stats) {
+    if (!operationStats[stat.operation]) {
+      operationStats[stat.operation] = {
+        count: 0,
+        successCount: 0,
+        failureCount: 0,
+        totalDuration: 0,
+        averageDuration: 0,
+      };
+    }
+    const opStat = operationStats[stat.operation];
+    if (opStat) {
+      opStat.count++;
+      opStat.totalDuration += stat.duration;
+      if (stat.success) opStat.successCount++;
+      else opStat.failureCount++;
+    }
+  }
+  for (const op in operationStats) {
+    const opStat = operationStats[op];
+    if (opStat && opStat.count > 0) opStat.averageDuration = opStat.totalDuration / opStat.count;
+  }
+
+  const errorStats: Record<string, number> = {};
+  for (const stat of stats.filter((s) => !s.success && s.error)) {
+    const errorType = stat.error!.type;
+    errorStats[errorType] = (errorStats[errorType] || 0) + 1;
+  }
+
+  return {
+    totalExecutions,
+    successfulExecutions,
+    failedExecutions,
+    successRate: totalExecutions > 0 ? successfulExecutions / totalExecutions : 0,
+    averageDuration,
+    totalDuration,
+    operationStats,
+    errorStats,
+    timeRange: timeRange || {
+      start: stats[0]?.startTime || new Date(),
+      end: stats[stats.length - 1]?.endTime || new Date(),
+    },
+  };
+}

package/src/execution-analytics/execution-analytics-helpers.ts

@@ -0,0 +1,83 @@
+/**
+ * Execution Analytics Plugin - Validation and utility helpers.
+ *
+ * Extracted from execution-analytics-plugin.ts to keep each file under 300 lines.
+ * @internal
+ */
+
+import type { IExecutionAnalyticsOptions, IExecutionStats } from './types';
+
+/**
+ * Validate and sanitize ExecutionAnalyticsPlugin options in-place.
+ * Invalid numeric values are reset to safe defaults. @internal
+ */
+export function validateExecutionAnalyticsOptions(
+  options: IExecutionAnalyticsOptions,
+  pluginOptions: { maxEntries: number; performanceThreshold: number },
+): void {
+  if (options.maxEntries !== undefined && options.maxEntries < 1) {
+    pluginOptions.maxEntries = 1000;
+  }
+  if (options.performanceThreshold !== undefined && options.performanceThreshold < 0) {
+    pluginOptions.performanceThreshold = 5000;
+  }
+}
+
+/** Generate a unique execution ID with an optional prefix. @internal */
+export function generateExecutionId(prefix: string, counter: number): string {
+  return `${prefix}-${Date.now()}-${counter}`;
+}
+
+/**
+ * Build an IExecutionStats record for an error event. @internal
+ */
+export function buildErrorExecutionStats(
+  executionId: string,
+  executionData: { startTime: number; operation: string },
+  error: Error,
+  trackErrors: boolean,
+  context?: { action?: string; tool?: string; attempt?: number },
+): IExecutionStats {
+  const duration = Date.now() - executionData.startTime;
+  const errorInfo = trackErrors
+    ? {
+        message: error.message,
+        ...(error.stack && { stack: error.stack }),
+        type: error.constructor.name,
+      }
+    : undefined;
+  return {
+    executionId,
+    operation: executionData.operation,
+    startTime: new Date(executionData.startTime),
+    endTime: new Date(),
+    duration,
+    success: false,
+    ...(errorInfo && { error: errorInfo }),
+    metadata: {
+      errorSource: 'onError-hook',
+      contextType: context ? typeof context : 'none',
+      hasContext: !!context,
+    },
+  };
+}
+
+/** Find the first active execution matching the given operation (and optionally the input). @internal */
+export function findActiveExecution(
+  activeExecutions: Map<string, { startTime: number; operation: string; input?: string }>,
+  operation: string,
+  input?: string,
+):
+  | {
+      executionId: string;
+      executionData: { startTime: number; operation: string; input?: string };
+    }
+  | undefined {
+  for (const [executionId, executionData] of activeExecutions.entries()) {
+    if (executionData.operation === operation) {
+      if (operation === 'run' && input && executionData.input !== input) continue;
+      return { executionId, executionData };
+    }
+  }
+  return undefined;
+}

package/src/execution-analytics/execution-analytics-plugin.ts

@@ -0,0 +1,315 @@
+import {
+  AbstractPlugin,
+  PluginCategory,
+  PluginPriority,
+  type IPluginErrorContext,
+  createLogger,
+  type ILogger,
+  type IRunOptions,
+  type TUniversalMessage,
+  isAssistantMessage,
+  type TToolParameters,
+  type IToolExecutionResult,
+} from '@robota-sdk/agent-core';
+import type {
+  IExecutionStats,
+  IAggregatedExecutionStats,
+  IExecutionAnalyticsOptions,
+  IExecutionAnalyticsPluginStats,
+} from './types';
+import { aggregateExecutionStats } from './analytics-aggregation';
+import {
+  validateExecutionAnalyticsOptions,
+  generateExecutionId,
+  findActiveExecution,
+  buildErrorExecutionStats,
+} from './execution-analytics-helpers';
+
+const DEFAULT_MAX_ENTRIES = 1000;
+const DEFAULT_PERFORMANCE_THRESHOLD_MS = 5000;
+const PREVIEW_LENGTH = 100;
+
+/**
+ * Tracks timing and success/failure of agent runs, provider calls, and tool executions.
+ * @extends AbstractPlugin
+ */
+export class ExecutionAnalyticsPlugin extends AbstractPlugin<
+  IExecutionAnalyticsOptions,
+  IExecutionAnalyticsPluginStats
+> {
+  name = 'ExecutionAnalyticsPlugin';
+  version = '1.0.0';
+
+  private pluginOptions: Required<IExecutionAnalyticsOptions>;
+  private logger: ILogger;
+  private activeExecutions: Map<string, { startTime: number; operation: string; input?: string }> =
+    new Map();
+  private executionHistory: IExecutionStats[] = [];
+  private executionCounter = 0;
+  private initialized = false;
+
+  constructor(options: IExecutionAnalyticsOptions = {}) {
+    super();
+    this.category = PluginCategory.MONITORING;
+    this.priority = PluginPriority.NORMAL;
+    this.pluginOptions = {
+      enabled: options.enabled ?? true,
+      maxEntries: options.maxEntries || DEFAULT_MAX_ENTRIES,
+      trackErrors: options.trackErrors ?? true,
+      performanceThreshold: options.performanceThreshold || DEFAULT_PERFORMANCE_THRESHOLD_MS,
+      enableWarnings: options.enableWarnings ?? true,
+      category: options.category ?? PluginCategory.MONITORING,
+      priority: options.priority ?? PluginPriority.NORMAL,
+      moduleEvents: options.moduleEvents ?? [],
+      subscribeToAllModuleEvents: options.subscribeToAllModuleEvents ?? false,
+    };
+    validateExecutionAnalyticsOptions(options, this.pluginOptions);
+    this.logger = createLogger('ExecutionAnalyticsPlugin');
+    this.beforeRun = this.beforeRun.bind(this);
+    this.afterRun = this.afterRun.bind(this);
+    this.beforeProviderCall = this.beforeProviderCall.bind(this);
+    this.afterProviderCall = this.afterProviderCall.bind(this);
+    this.initialized = true;
+  }
+
+  override beforeRun = async (input: string, _options?: IRunOptions): Promise<void> => {
+    this.activeExecutions.set(generateExecutionId('exec', ++this.executionCounter), {
+      startTime: Date.now(),
+      operation: 'run',
+      input: input.substring(0, PREVIEW_LENGTH),
+    });
+  };
+
+  override afterRun = async (
+    input: string,
+    response: string,
+    options?: IRunOptions,
+  ): Promise<void> => {
+    const execution = findActiveExecution(this.activeExecutions, 'run', input);
+    if (!execution) return;
+    const { executionId, executionData } = execution;
+    const duration = Date.now() - executionData.startTime;
+    this.recordStats({
+      executionId,
+      operation: 'run',
+      startTime: new Date(executionData.startTime),
+      endTime: new Date(),
+      duration,
+      success: true,
+      metadata: {
+        inputLength: input.length,
+        responseLength: response.length,
+        hasOptions: !!options,
+        modelName: String(options?.metadata?.['model'] || 'unknown'),
+      },
+    });
+    this.activeExecutions.delete(executionId);
+    if (this.pluginOptions.enableWarnings && duration > this.pluginOptions.performanceThreshold) {
+      this.logger.warn('Slow run execution detected', {
+        executionId,
+        duration,
+        threshold: this.pluginOptions.performanceThreshold,
+      });
+    }
+  };
+
+  override beforeProviderCall = async (messages: TUniversalMessage[]): Promise<void> => {
+    this.activeExecutions.set(generateExecutionId('provider', ++this.executionCounter), {
+      startTime: Date.now(),
+      operation: 'provider-call',
+      input: messages[0]?.content || 'N/A',
+    });
+  };
+
+  override afterProviderCall = async (
+    messages: TUniversalMessage[],
+    response: TUniversalMessage,
+  ): Promise<void> => {
+    const execution = findActiveExecution(
+      this.activeExecutions,
+      'provider-call',
+      messages[0]?.content || '',
+    );
+    if (!execution) return;
+    const { executionId, executionData } = execution;
+    const duration = Date.now() - executionData.startTime;
+    this.recordStats({
+      executionId,
+      operation: 'provider-call',
+      startTime: new Date(executionData.startTime),
+      endTime: new Date(),
+      duration,
+      success: true,
+      metadata: {
+        inputLength: messages[0]?.content?.length || 0,
+        responseLength: response.content?.length || 0,
+        hasToolCalls: !!(
+          isAssistantMessage(response) &&
+          response.toolCalls &&
+          response.toolCalls.length > 0
+        ),
+        toolCallCount:
+          isAssistantMessage(response) && response.toolCalls ? response.toolCalls.length : 0,
+      },
+    });
+    this.activeExecutions.delete(executionId);
+    if (this.pluginOptions.enableWarnings && duration > this.pluginOptions.performanceThreshold) {
+      this.logger.warn('Slow provider call detected', {
+        executionId,
+        duration,
+        threshold: this.pluginOptions.performanceThreshold,
+      });
+    }
+  };
+
+  override async beforeToolCall(toolName: string, _parameters: TToolParameters): Promise<void> {
+    this.activeExecutions.set(generateExecutionId('tool', ++this.executionCounter), {
+      startTime: Date.now(),
+      operation: 'tool-call',
+      input: toolName,
+    });
+  }
+
+  override async afterToolCall(
+    toolName: string,
+    parameters: TToolParameters,
+    result: IToolExecutionResult,
+  ): Promise<void> {
+    const execution = findActiveExecution(this.activeExecutions, 'tool-call', toolName);
+    if (!execution) return;
+    const { executionId, executionData } = execution;
+    const duration = Date.now() - executionData.startTime;
+    const success = !result?.error;
+    const errorInfo =
+      result?.error && this.pluginOptions.trackErrors
+        ? { message: String(result.error), type: 'ToolExecutionError' }
+        : undefined;
+    this.recordStats({
+      executionId,
+      operation: 'tool-call',
+      startTime: new Date(executionData.startTime),
+      endTime: new Date(),
+      duration,
+      success,
+      ...(errorInfo && { error: errorInfo }),
+      metadata: {
+        toolName,
+        parameterCount: Object.keys(parameters).length,
+        resultType: typeof result,
+        hasError: !!result?.error,
+      },
+    });
+    this.activeExecutions.delete(executionId);
+  }
+
+  override async onError(error: Error, context?: IPluginErrorContext): Promise<void> {
+    const activeExecution = Array.from(this.activeExecutions.entries())[0];
+    if (activeExecution) {
+      const [executionId, executionData] = activeExecution;
+      this.recordStats(
+        buildErrorExecutionStats(
+          executionId,
+          executionData,
+          error,
+          this.pluginOptions.trackErrors,
+          context,
+        ),
+      );
+      this.activeExecutions.delete(executionId);
+    }
+  }
+
+  getExecutionStats(operation?: string, timeRange?: { start: Date; end: Date }): IExecutionStats[] {
+    let filtered = this.executionHistory;
+    if (operation) filtered = filtered.filter((stat) => stat.operation === operation);
+    if (timeRange)
+      filtered = filtered.filter(
+        (stat) => stat.startTime >= timeRange.start && stat.startTime <= timeRange.end,
+      );
+    return [...filtered];
+  }
+
+  getAggregatedStats(timeRange?: { start: Date; end: Date }): IAggregatedExecutionStats {
+    return aggregateExecutionStats(this.getExecutionStats(undefined, timeRange), timeRange);
+  }
+
+  clearStats(): void {
+    this.executionHistory = [];
+    this.activeExecutions.clear();
+    this.executionCounter = 0;
+  }
+
+  getActiveExecutions(): Array<{ executionId: string; operation: string; duration: number }> {
+    const now = Date.now();
+    return Array.from(this.activeExecutions.entries()).map(([executionId, data]) => ({
+      executionId,
+      operation: data.operation,
+      duration: now - data.startTime,
+    }));
+  }
+
+  getPluginStats(): {
+    totalRecorded: number;
+    activeExecutions: number;
+    memoryUsage: number;
+    oldestRecord?: Date;
+    newestRecord?: Date;
+  } {
+    const oldest = this.executionHistory[0];
+    const newest = this.executionHistory[this.executionHistory.length - 1];
+    return {
+      totalRecorded: this.executionHistory.length,
+      activeExecutions: this.activeExecutions.size,
+      memoryUsage: this.executionHistory.length + this.activeExecutions.size,
+      ...(oldest && { oldestRecord: oldest.startTime }),
+      ...(newest && { newestRecord: newest.endTime }),
+    };
+  }
+
+  async destroy(): Promise<void> {
+    this.clearStats();
+  }
+  getExecutionData(): IExecutionStats[] {
+    return [...this.executionHistory];
+  }
+  getAnalyticsStats(): IAggregatedExecutionStats {
+    return this.getAggregatedStats();
+  }
+  clearExecutionData(): void {
+    this.clearStats();
+  }
+
+  override getStatus() {
+    return {
+      name: this.name,
+      version: this.version,
+      enabled: this.enabled,
+      initialized: this.initialized,
+      category: this.category,
+      priority: this.priority,
+      subscribedEventsCount: this.subscribedEvents.length,
+      hasEventEmitter: !!this.eventEmitter,
+    };
+  }
+
+  override getStats(): IExecutionAnalyticsPluginStats {
+    const newest = this.executionHistory[this.executionHistory.length - 1];
+    const oldest = this.executionHistory[0];
+    return {
+      enabled: this.enabled,
+      calls: this.executionHistory.length,
+      errors: this.executionHistory.filter((e) => !e.success).length,
+      ...(newest?.endTime && { lastActivity: newest.endTime }),
+      totalRecorded: this.executionHistory.length,
+      activeExecutions: this.activeExecutions.size,
+      memoryUsage: this.executionHistory.length + this.activeExecutions.size,
+      ...(oldest && { oldestRecord: oldest.startTime }),
+      ...(newest && { newestRecord: newest.endTime }),
+    };
+  }
+
+  private recordStats(stats: IExecutionStats): void {
+    this.executionHistory.push(stats);
+    if (this.executionHistory.length > this.pluginOptions.maxEntries) this.executionHistory.shift();
+  }
+}