autotel 4.1.0 → 4.2.1

package/src/circuit-breaker.test.ts

@@ -1,341 +0,0 @@
-/**
- * Tests for circuit breaker
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import {
-  CircuitBreaker,
-  CircuitState,
-  CircuitOpenError,
-} from './circuit-breaker';
-
-describe('CircuitBreaker', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  describe('CLOSED state (normal operation)', () => {
-    it('should execute function successfully when closed', async () => {
-      const cb = new CircuitBreaker('test');
-
-      const result = await cb.execute(async () => 'success');
-
-      expect(result).toBe('success');
-      expect(cb.getState()).toBe(CircuitState.CLOSED);
-    });
-
-    it('should record failures but stay closed under threshold', async () => {
-      const cb = new CircuitBreaker('test', {
-        failureThreshold: 5,
-        resetTimeout: 30_000,
-        windowSize: 60_000,
-      });
-
-      // 4 failures (under threshold of 5)
-      for (let i = 0; i < 4; i++) {
-        try {
-          await cb.execute(async () => {
-            throw new Error('test error');
-          });
-        } catch {
-          // Expected
-        }
-      }
-
-      expect(cb.getState()).toBe(CircuitState.CLOSED);
-      expect(cb.getFailureCount()).toBe(4);
-    });
-  });
-
-  describe('OPEN state (fast-fail)', () => {
-    it('should open circuit after threshold failures', async () => {
-      const cb = new CircuitBreaker('test', {
-        failureThreshold: 3,
-        resetTimeout: 30_000,
-        windowSize: 60_000,
-      });
-
-      // Trigger 3 failures to open circuit
-      for (let i = 0; i < 3; i++) {
-        try {
-          await cb.execute(async () => {
-            throw new Error('adapter error');
-          });
-        } catch {
-          // Expected
-        }
-      }
-
-      expect(cb.getState()).toBe(CircuitState.OPEN);
-      expect(cb.getFailureCount()).toBe(3);
-    });
-
-    it('should fast-fail when circuit is open', async () => {
-      const cb = new CircuitBreaker('test-adapter', {
-        failureThreshold: 2,
-        resetTimeout: 30_000,
-        windowSize: 60_000,
-      });
-
-      // Open the circuit
-      for (let i = 0; i < 2; i++) {
-        try {
-          await cb.execute(async () => {
-            throw new Error('error');
-          });
-        } catch {
-          // Expected
-        }
-      }
-
-      // Should fast-fail without calling function
-      await expect(
-        cb.execute(async () => 'should not be called'),
-      ).rejects.toThrow(CircuitOpenError);
-
-      expect(cb.getState()).toBe(CircuitState.OPEN);
-    });
-
-    it('should transition to half-open after reset timeout', async () => {
-      const cb = new CircuitBreaker('test', {
-        failureThreshold: 2,
-        resetTimeout: 30_000,
-        windowSize: 60_000,
-      });
-
-      // Open circuit
-      for (let i = 0; i < 2; i++) {
-        try {
-          await cb.execute(async () => {
-            throw new Error('error');
-          });
-        } catch {
-          // Expected
-        }
-      }
-
-      expect(cb.getState()).toBe(CircuitState.OPEN);
-
-      // Advance time past reset timeout
-      vi.advanceTimersByTime(31_000);
-
-      // Next call should transition to half-open
-      const result = await cb.execute(async () => 'recovered');
-
-      expect(result).toBe('recovered');
-      expect(cb.getState()).toBe(CircuitState.CLOSED);
-    });
-  });
-
-  describe('HALF_OPEN state (testing recovery)', () => {
-    it('should close circuit on successful test request', async () => {
-      const cb = new CircuitBreaker('test', {
-        failureThreshold: 2,
-        resetTimeout: 30_000,
-        windowSize: 60_000,
-      });
-
-      // Open circuit
-      cb.forceOpen();
-      expect(cb.getState()).toBe(CircuitState.OPEN);
-
-      // Wait for reset timeout
-      vi.advanceTimersByTime(31_000);
-
-      // Successful test request should close circuit
-      await cb.execute(async () => 'success');
-
-      expect(cb.getState()).toBe(CircuitState.CLOSED);
-      expect(cb.getFailureCount()).toBe(0);
-    });
-
-    it('should reopen circuit if test request fails', async () => {
-      const cb = new CircuitBreaker('test', {
-        failureThreshold: 1,
-        resetTimeout: 30_000,
-        windowSize: 60_000,
-      });
-
-      // Open circuit
-      try {
-        await cb.execute(async () => {
-          throw new Error('error');
-        });
-      } catch {
-        // Expected
-      }
-
-      expect(cb.getState()).toBe(CircuitState.OPEN);
-
-      // Wait for reset timeout
-      vi.advanceTimersByTime(31_000);
-
-      // Failed test request should reopen circuit
-      try {
-        await cb.execute(async () => {
-          throw new Error('still failing');
-        });
-      } catch {
-        // Expected
-      }
-
-      expect(cb.getState()).toBe(CircuitState.OPEN);
-    });
-  });
-
-  describe('Time window management', () => {
-    it('should only count failures within time window', async () => {
-      const cb = new CircuitBreaker('test', {
-        failureThreshold: 3,
-        resetTimeout: 30_000,
-        windowSize: 10_000, // 10 second window
-      });
-
-      // Record 2 failures
-      for (let i = 0; i < 2; i++) {
-        try {
-          await cb.execute(async () => {
-            throw new Error('error');
-          });
-        } catch {
-          // Expected
-        }
-      }
-
-      expect(cb.getFailureCount()).toBe(2);
-
-      // Advance time past window
-      vi.advanceTimersByTime(11_000);
-
-      // Old failures should be cleared
-      expect(cb.getFailureCount()).toBe(0);
-      expect(cb.getState()).toBe(CircuitState.CLOSED);
-    });
-
-    it('should track failure timestamps correctly', async () => {
-      const cb = new CircuitBreaker('test', {
-        failureThreshold: 5,
-        resetTimeout: 30_000,
-        windowSize: 60_000,
-      });
-
-      // Record failures over time
-      for (let i = 0; i < 3; i++) {
-        try {
-          await cb.execute(async () => {
-            throw new Error('error');
-          });
-        } catch {
-          // Expected
-        }
-        vi.advanceTimersByTime(5000); // 5 seconds between failures
-      }
-
-      const failures = cb.getRecentFailures();
-      expect(failures).toHaveLength(3);
-      expect(failures[0]?.error).toBe('error');
-    });
-  });
-
-  describe('Manual control', () => {
-    it('should allow manual reset', async () => {
-      const cb = new CircuitBreaker('test', {
-        failureThreshold: 2,
-        resetTimeout: 30_000,
-        windowSize: 60_000,
-      });
-
-      // Open circuit
-      for (let i = 0; i < 2; i++) {
-        try {
-          await cb.execute(async () => {
-            throw new Error('error');
-          });
-        } catch {
-          // Expected
-        }
-      }
-
-      expect(cb.getState()).toBe(CircuitState.OPEN);
-
-      // Manual reset
-      cb.forceReset();
-
-      expect(cb.getState()).toBe(CircuitState.CLOSED);
-      expect(cb.getFailureCount()).toBe(0);
-    });
-
-    it('should allow manual open', () => {
-      const cb = new CircuitBreaker('test');
-
-      expect(cb.getState()).toBe(CircuitState.CLOSED);
-
-      cb.forceOpen();
-
-      expect(cb.getState()).toBe(CircuitState.OPEN);
-    });
-  });
-
-  describe('Configuration', () => {
-    it('should use default config values', () => {
-      const cb = new CircuitBreaker('test');
-
-      // Should use default threshold of 5
-      expect(cb.getFailureCount()).toBe(0);
-      expect(cb.getState()).toBe(CircuitState.CLOSED);
-    });
-
-    it('should allow custom config', async () => {
-      const cb = new CircuitBreaker('test', {
-        failureThreshold: 2,
-        resetTimeout: 5000,
-        windowSize: 10_000,
-      });
-
-      // Should open after 2 failures (custom threshold)
-      for (let i = 0; i < 2; i++) {
-        try {
-          await cb.execute(async () => {
-            throw new Error('error');
-          });
-        } catch {
-          // Expected
-        }
-      }
-
-      expect(cb.getState()).toBe(CircuitState.OPEN);
-    });
-  });
-
-  describe('Error handling', () => {
-    it('should record error messages', async () => {
-      const cb = new CircuitBreaker('test');
-
-      try {
-        await cb.execute(async () => {
-          throw new Error('specific error message');
-        });
-      } catch {
-        // Expected
-      }
-
-      const failures = cb.getRecentFailures();
-      expect(failures[0]?.error).toBe('specific error message');
-    });
-
-    it('should handle non-Error throws', async () => {
-      const cb = new CircuitBreaker('test');
-
-      try {
-        await cb.execute(async () => {
-          throw 'string error';
-        });
-      } catch {
-        // Expected
-      }
-
-      const failures = cb.getRecentFailures();
-      expect(failures[0]?.error).toBe('string error');
-    });
-  });
-});

package/src/circuit-breaker.ts

@@ -1,184 +0,0 @@
-/**
- * Circuit breaker for event subscribers
- *
- * Prevents cascading failures by fast-failing when an (subscriber) is unhealthy.
- * Uses the circuit breaker pattern with three states:
- * - CLOSED: Normal operation ((subscriber) working)
- * - OPEN: Fast-fail mode ((subscriber) down)
- * - HALF_OPEN: Testing if (subscriber) recovered
- */
-
-export interface CircuitBreakerConfig {
-  /** Number of failures before opening circuit (default: 5) */
-  failureThreshold: number;
-  /** Time to wait before trying again in ms (default: 30000 = 30s) */
-  resetTimeout: number;
-  /** Time window for counting failures in ms (default: 60000 = 1min) */
-  windowSize: number;
-}
-
-const DEFAULT_CONFIG: CircuitBreakerConfig = {
-  failureThreshold: 5,
-  resetTimeout: 30_000, // 30 seconds
-  windowSize: 60_000, // 1 minute
-};
-
-export type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
-
-export const CircuitState = {
-  CLOSED: 'CLOSED' as const, // Normal operation
-  OPEN: 'OPEN' as const, // Fast-fail mode
-  HALF_OPEN: 'HALF_OPEN' as const, // Testing recovery
-} as const;
-
-interface FailureRecord {
-  timestamp: number;
-  error: string;
-}
-
-/**
- * Circuit breaker implementation
- *
- * Tracks failures and automatically opens the circuit to prevent
- * overwhelming failing subscribers.
- */
-export class CircuitBreaker {
-  private state: CircuitState = CircuitState.CLOSED;
-  private failures: FailureRecord[] = [];
-  private lastFailureTime: number = 0;
-  private readonly config: CircuitBreakerConfig;
-  private readonly name: string;
-
-  constructor(name: string, config?: Partial<CircuitBreakerConfig>) {
-    this.name = name;
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  /**
-   * Execute a function with circuit breaker protection
-   * Throws CircuitOpenError if circuit is open
-   */
-  async execute<T>(fn: () => Promise<T>): Promise<T> {
-    // Check if circuit is open
-    if (this.state === CircuitState.OPEN) {
-      // Check if we should transition to half-open
-      const now = Date.now();
-      if (now - this.lastFailureTime >= this.config.resetTimeout) {
-        this.state = CircuitState.HALF_OPEN;
-      } else {
-        throw new CircuitOpenError(
-          `Circuit breaker is OPEN for ${this.name}. ` +
-            `Will retry in ${Math.ceil((this.config.resetTimeout - (now - this.lastFailureTime)) / 1000)}s`,
-        );
-      }
-    }
-
-    try {
-      const result = await fn();
-
-      // Success! Close circuit if it was half-open
-      if (this.state === CircuitState.HALF_OPEN) {
-        this.reset();
-      }
-
-      return result;
-    } catch (error) {
-      this.recordFailure(error);
-      throw error;
-    }
-  }
-
-  /**
-   * Record a failure and potentially open the circuit
-   */
-  private recordFailure(error: unknown): void {
-    const now = Date.now();
-
-    // Remove old failures outside the time window
-    this.failures = this.failures.filter(
-      (f) => now - f.timestamp < this.config.windowSize,
-    );
-
-    // Record new failure
-    this.failures.push({
-      timestamp: now,
-      error: error instanceof Error ? error.message : String(error),
-    });
-
-    this.lastFailureTime = now;
-
-    // Check if we should open the circuit
-    if (this.failures.length >= this.config.failureThreshold) {
-      if (this.state === CircuitState.HALF_OPEN) {
-        // Failed during test - reopen circuit
-        this.state = CircuitState.OPEN;
-      } else if (this.state === CircuitState.CLOSED) {
-        // Too many failures - open circuit
-        this.state = CircuitState.OPEN;
-      }
-    }
-  }
-
-  /**
-   * Reset the circuit breaker (on success)
-   */
-  private reset(): void {
-    this.state = CircuitState.CLOSED;
-    this.failures = [];
-    this.lastFailureTime = 0;
-  }
-
-  /**
-   * Get current state (for monitoring)
-   */
-  getState(): CircuitState {
-    return this.state;
-  }
-
-  /**
-   * Get failure count in current window
-   */
-  getFailureCount(): number {
-    const now = Date.now();
-    // Clean up old failures
-    this.failures = this.failures.filter(
-      (f) => now - f.timestamp < this.config.windowSize,
-    );
-    return this.failures.length;
-  }
-
-  /**
-   * Get recent failures (for debugging)
-   */
-  getRecentFailures(): FailureRecord[] {
-    const now = Date.now();
-    return this.failures.filter(
-      (f) => now - f.timestamp < this.config.windowSize,
-    );
-  }
-
-  /**
-   * Manually reset the circuit breaker (for testing or manual intervention)
-   */
-  forceReset(): void {
-    this.reset();
-  }
-
-  /**
-   * Manually open the circuit (for testing or manual intervention)
-   */
-  forceOpen(): void {
-    this.state = CircuitState.OPEN;
-    this.lastFailureTime = Date.now();
-  }
-}
-
-/**
- * Error thrown when circuit is open
- */
-export class CircuitOpenError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'CircuitOpenError';
-  }
-}

package/src/config.test.ts

@@ -1,94 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { configure, getConfig, resetConfig } from './config';
-
-describe('configure()', () => {
-  beforeEach(() => {
-    resetConfig();
-  });
-
-  it('should set custom tracer name', () => {
-    configure({
-      tracerName: 'my-custom-tracer',
-    });
-
-    const config = getConfig();
-    expect(config.tracerName).toBe('my-custom-tracer');
-  });
-
-  it('should set custom meter name', () => {
-    configure({
-      meterName: 'my-custom-meter',
-    });
-
-    const config = getConfig();
-    expect(config.meterName).toBe('my-custom-meter');
-  });
-
-  it('should allow custom tracer instance', () => {
-    const mockTracer = {
-      startActiveSpan: vi.fn(),
-      startSpan: vi.fn(),
-    };
-
-    configure({
-      tracer: mockTracer as any,
-    });
-
-    const config = getConfig();
-    expect(config.tracer).toBe(mockTracer);
-  });
-
-  it('should allow custom meter instance', () => {
-    const mockMeter = {
-      createCounter: vi.fn(),
-      createHistogram: vi.fn(),
-      createUpDownCounter: vi.fn(),
-      createObservableGauge: vi.fn(),
-      createObservableCounter: vi.fn(),
-      createObservableUpDownCounter: vi.fn(),
-    };
-
-    configure({
-      meter: mockMeter as any,
-    });
-
-    const config = getConfig();
-    expect(config.meter).toBe(mockMeter);
-  });
-
-  it('should merge configurations', () => {
-    configure({
-      tracerName: 'tracer-1',
-    });
-
-    configure({
-      meterName: 'meter-1',
-    });
-
-    const config = getConfig();
-    expect(config.tracerName).toBe('tracer-1');
-    expect(config.meterName).toBe('meter-1');
-  });
-
-  it('should reset to defaults', () => {
-    configure({
-      tracerName: 'custom-tracer',
-      meterName: 'custom-meter',
-    });
-
-    resetConfig();
-
-    const config = getConfig();
-    expect(config.tracerName).toBe('app');
-    expect(config.meterName).toBe('app');
-  });
-
-  it('should expose feature flags', () => {
-    const config = getConfig();
-    expect(config.featureFlags).toBeDefined();
-    expect(typeof config.featureFlags.ENABLE_TRACING).toBe('boolean');
-    expect(typeof config.featureFlags.ENABLE_METRICS_BY_DEFAULT).toBe(
-      'boolean',
-    );
-  });
-});