@dotdo/postgres 0.1.0

package/src/routing/circuit-breaker.test.ts

@@ -0,0 +1,1505 @@
+/**
+ * Tests for Circuit Breaker Pattern
+ *
+ * Task: postgres-rai
+ *
+ * Tests all state transitions and behaviors of the circuit breaker
+ * pattern implementation for Durable Object resilience.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import {
+  CircuitBreaker,
+  CircuitOpenError,
+  DOCircuitBreakerWrapper,
+  CircuitState,
+  CircuitBreakerEvent,
+  CircuitBreakerConfig,
+  CircuitBreakerStats,
+  DOStub,
+  DefaultMetricsCollector,
+  CircuitBreakerMetricsCollector,
+  CircuitBreakerMetricsSummary,
+} from './circuit-breaker'
+
+describe('CircuitBreaker', () => {
+  describe('initial state', () => {
+    it('should start in CLOSED state', () => {
+      const cb = new CircuitBreaker()
+      expect(cb.getState('test-instance')).toBe('CLOSED')
+    })
+
+    it('should allow execution in initial CLOSED state', () => {
+      const cb = new CircuitBreaker()
+      expect(cb.canExecute('test-instance')).toBe(true)
+    })
+
+    it('should initialize with default configuration', () => {
+      const cb = new CircuitBreaker()
+      const config = cb.getConfig()
+
+      expect(config.failureThreshold).toBe(5)
+      expect(config.resetTimeoutMs).toBe(30000)
+      expect(config.halfOpenSuccessThreshold).toBe(3)
+      expect(config.failureWindowMs).toBe(60000)
+    })
+
+    it('should accept custom configuration', () => {
+      const cb = new CircuitBreaker({
+        failureThreshold: 3,
+        resetTimeoutMs: 10000,
+        halfOpenSuccessThreshold: 2,
+        failureWindowMs: 30000,
+      })
+      const config = cb.getConfig()
+
+      expect(config.failureThreshold).toBe(3)
+      expect(config.resetTimeoutMs).toBe(10000)
+      expect(config.halfOpenSuccessThreshold).toBe(2)
+      expect(config.failureWindowMs).toBe(30000)
+    })
+  })
+
+  describe('CLOSED -> OPEN transition', () => {
+    it('should open circuit after consecutive failures exceed threshold', () => {
+      const cb = new CircuitBreaker({ failureThreshold: 3 })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      expect(cb.getState(instanceId)).toBe('CLOSED')
+
+      cb.recordFailure(instanceId)
+      expect(cb.getState(instanceId)).toBe('CLOSED')
+
+      cb.recordFailure(instanceId)
+      expect(cb.getState(instanceId)).toBe('OPEN')
+    })
+
+    it('should not allow execution when OPEN', () => {
+      const cb = new CircuitBreaker({ failureThreshold: 2 })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+
+      expect(cb.getState(instanceId)).toBe('OPEN')
+      expect(cb.canExecute(instanceId)).toBe(false)
+    })
+
+    it('should emit STATE_CHANGE event when opening', () => {
+      const events: CircuitBreakerEvent[] = []
+      const cb = new CircuitBreaker({
+        failureThreshold: 2,
+        onEvent: (event) => events.push(event),
+      })
+
+      cb.recordFailure('test-instance')
+      cb.recordFailure('test-instance')
+
+      const stateChangeEvent = events.find(e => e.type === 'STATE_CHANGE')
+      expect(stateChangeEvent).toBeDefined()
+      expect(stateChangeEvent!.type).toBe('STATE_CHANGE')
+      if (stateChangeEvent!.type === 'STATE_CHANGE') {
+        expect(stateChangeEvent!.from).toBe('CLOSED')
+        expect(stateChangeEvent!.to).toBe('OPEN')
+      }
+    })
+
+    it('should emit FAILURE_RECORDED events', () => {
+      const events: CircuitBreakerEvent[] = []
+      const cb = new CircuitBreaker({
+        failureThreshold: 5,
+        onEvent: (event) => events.push(event),
+      })
+
+      cb.recordFailure('test-instance')
+
+      const failureEvent = events.find(e => e.type === 'FAILURE_RECORDED')
+      expect(failureEvent).toBeDefined()
+      if (failureEvent?.type === 'FAILURE_RECORDED') {
+        expect(failureEvent.failureCount).toBe(1)
+      }
+    })
+  })
+
+  describe('OPEN -> HALF_OPEN transition', () => {
+    it('should transition to HALF_OPEN after reset timeout', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 2,
+        resetTimeoutMs: 1000,
+      })
+      const instanceId = 'test-instance'
+
+      // Open the circuit
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+      expect(cb.getState(instanceId)).toBe('OPEN')
+
+      // Advance time past reset timeout
+      vi.advanceTimersByTime(1001)
+
+      // getState should transition to HALF_OPEN
+      expect(cb.getState(instanceId)).toBe('HALF_OPEN')
+
+      vi.useRealTimers()
+    })
+
+    it('should allow execution in HALF_OPEN state', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 2,
+        resetTimeoutMs: 1000,
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+
+      vi.advanceTimersByTime(1001)
+
+      expect(cb.getState(instanceId)).toBe('HALF_OPEN')
+      expect(cb.canExecute(instanceId)).toBe(true)
+
+      vi.useRealTimers()
+    })
+
+    it('should emit STATE_CHANGE event when transitioning to HALF_OPEN', async () => {
+      vi.useFakeTimers()
+
+      const events: CircuitBreakerEvent[] = []
+      const cb = new CircuitBreaker({
+        failureThreshold: 2,
+        resetTimeoutMs: 1000,
+        onEvent: (event) => events.push(event),
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+
+      vi.advanceTimersByTime(1001)
+      cb.getState(instanceId) // Trigger transition
+
+      const halfOpenEvent = events.find(
+        e => e.type === 'STATE_CHANGE' && e.type === 'STATE_CHANGE' && e.to === 'HALF_OPEN'
+      )
+      expect(halfOpenEvent).toBeDefined()
+
+      vi.useRealTimers()
+    })
+  })
+
+  describe('HALF_OPEN -> CLOSED transition', () => {
+    it('should close circuit after successful requests in HALF_OPEN', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 2,
+        resetTimeoutMs: 1000,
+        halfOpenSuccessThreshold: 3,
+      })
+      const instanceId = 'test-instance'
+
+      // Open the circuit
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+
+      // Move to HALF_OPEN
+      vi.advanceTimersByTime(1001)
+      expect(cb.getState(instanceId)).toBe('HALF_OPEN')
+
+      // Record successful requests
+      cb.recordSuccess(instanceId)
+      expect(cb.getState(instanceId)).toBe('HALF_OPEN')
+
+      cb.recordSuccess(instanceId)
+      expect(cb.getState(instanceId)).toBe('HALF_OPEN')
+
+      cb.recordSuccess(instanceId)
+      expect(cb.getState(instanceId)).toBe('CLOSED')
+
+      vi.useRealTimers()
+    })
+
+    it('should emit HALF_OPEN_TEST events on success', async () => {
+      vi.useFakeTimers()
+
+      const events: CircuitBreakerEvent[] = []
+      const cb = new CircuitBreaker({
+        failureThreshold: 2,
+        resetTimeoutMs: 1000,
+        halfOpenSuccessThreshold: 1,
+        onEvent: (event) => events.push(event),
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+      vi.advanceTimersByTime(1001)
+      cb.getState(instanceId) // Trigger HALF_OPEN
+
+      cb.recordSuccess(instanceId)
+
+      const halfOpenTest = events.find(
+        e => e.type === 'HALF_OPEN_TEST' && e.success === true
+      )
+      expect(halfOpenTest).toBeDefined()
+
+      vi.useRealTimers()
+    })
+
+    it('should reset failure count when closing', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 2,
+        resetTimeoutMs: 1000,
+        halfOpenSuccessThreshold: 1,
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+      vi.advanceTimersByTime(1001)
+      cb.getState(instanceId)
+      cb.recordSuccess(instanceId)
+
+      expect(cb.getState(instanceId)).toBe('CLOSED')
+
+      // Should need full failure threshold again to open
+      cb.recordFailure(instanceId)
+      expect(cb.getState(instanceId)).toBe('CLOSED')
+
+      cb.recordFailure(instanceId)
+      expect(cb.getState(instanceId)).toBe('OPEN')
+
+      vi.useRealTimers()
+    })
+  })
+
+  describe('HALF_OPEN -> OPEN transition', () => {
+    it('should reopen circuit on failure in HALF_OPEN state', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 2,
+        resetTimeoutMs: 1000,
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+      vi.advanceTimersByTime(1001)
+
+      expect(cb.getState(instanceId)).toBe('HALF_OPEN')
+
+      cb.recordFailure(instanceId)
+
+      expect(cb.getState(instanceId)).toBe('OPEN')
+
+      vi.useRealTimers()
+    })
+
+    it('should emit HALF_OPEN_TEST event with success=false on failure', async () => {
+      vi.useFakeTimers()
+
+      const events: CircuitBreakerEvent[] = []
+      const cb = new CircuitBreaker({
+        failureThreshold: 2,
+        resetTimeoutMs: 1000,
+        onEvent: (event) => events.push(event),
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+      vi.advanceTimersByTime(1001)
+      cb.getState(instanceId)
+      cb.recordFailure(instanceId)
+
+      const halfOpenTest = events.find(
+        e => e.type === 'HALF_OPEN_TEST' && e.success === false
+      )
+      expect(halfOpenTest).toBeDefined()
+
+      vi.useRealTimers()
+    })
+
+    it('should reset timeout on reopen', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 2,
+        resetTimeoutMs: 1000,
+        enableExponentialBackoff: false, // Disable backoff for this test
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+      vi.advanceTimersByTime(1001)
+      cb.getState(instanceId) // HALF_OPEN
+
+      cb.recordFailure(instanceId) // Back to OPEN
+
+      // Should not transition immediately
+      expect(cb.getState(instanceId)).toBe('OPEN')
+
+      // Should need full timeout again
+      vi.advanceTimersByTime(500)
+      expect(cb.getState(instanceId)).toBe('OPEN')
+
+      vi.advanceTimersByTime(501)
+      expect(cb.getState(instanceId)).toBe('HALF_OPEN')
+
+      vi.useRealTimers()
+    })
+  })
+
+  describe('success in CLOSED state', () => {
+    it('should reset failure count on success', () => {
+      const cb = new CircuitBreaker({ failureThreshold: 3 })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+
+      const statsBefore = cb.getStats(instanceId)
+      expect(statsBefore.failureCount).toBe(2)
+
+      cb.recordSuccess(instanceId)
+
+      const statsAfter = cb.getStats(instanceId)
+      expect(statsAfter.failureCount).toBe(0)
+    })
+
+    it('should emit SUCCESS_RECORDED event', () => {
+      const events: CircuitBreakerEvent[] = []
+      const cb = new CircuitBreaker({
+        onEvent: (event) => events.push(event),
+      })
+
+      cb.recordSuccess('test-instance')
+
+      const successEvent = events.find(e => e.type === 'SUCCESS_RECORDED')
+      expect(successEvent).toBeDefined()
+    })
+  })
+
+  describe('failure window', () => {
+    it('should only count failures within the window', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 3,
+        failureWindowMs: 1000,
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+
+      // Advance past window
+      vi.advanceTimersByTime(1001)
+
+      // This failure should only count as 1 (old failures expired)
+      cb.recordFailure(instanceId)
+
+      expect(cb.getState(instanceId)).toBe('CLOSED')
+
+      // Need 2 more failures
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+
+      expect(cb.getState(instanceId)).toBe('OPEN')
+
+      vi.useRealTimers()
+    })
+  })
+
+  describe('execute()', () => {
+    it('should execute function when circuit is CLOSED', async () => {
+      const cb = new CircuitBreaker()
+      const fn = vi.fn().mockResolvedValue('success')
+
+      const result = await cb.execute('test-instance', fn)
+
+      expect(fn).toHaveBeenCalled()
+      expect(result).toBe('success')
+    })
+
+    it('should record success on successful execution', async () => {
+      const cb = new CircuitBreaker()
+      const fn = vi.fn().mockResolvedValue('success')
+
+      await cb.execute('test-instance', fn)
+
+      const stats = cb.getStats('test-instance')
+      expect(stats.totalSuccesses).toBe(1)
+    })
+
+    it('should record failure on failed execution', async () => {
+      const cb = new CircuitBreaker()
+      const fn = vi.fn().mockRejectedValue(new Error('fail'))
+
+      await expect(cb.execute('test-instance', fn)).rejects.toThrow('fail')
+
+      const stats = cb.getStats('test-instance')
+      expect(stats.totalFailures).toBe(1)
+    })
+
+    it('should throw CircuitOpenError when circuit is OPEN', async () => {
+      const cb = new CircuitBreaker({ failureThreshold: 1 })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+
+      const fn = vi.fn()
+
+      await expect(cb.execute(instanceId, fn)).rejects.toThrow(CircuitOpenError)
+      expect(fn).not.toHaveBeenCalled()
+    })
+
+    it('should include retry information in CircuitOpenError', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 1,
+        resetTimeoutMs: 5000,
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+
+      vi.advanceTimersByTime(1000)
+
+      try {
+        await cb.execute(instanceId, vi.fn())
+        expect.fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CircuitOpenError)
+        if (error instanceof CircuitOpenError) {
+          expect(error.instanceId).toBe(instanceId)
+          expect(error.state).toBe('OPEN')
+          expect(error.retryAfterMs).toBeCloseTo(4000, -2)
+        }
+      }
+
+      vi.useRealTimers()
+    })
+
+    it('should emit REQUEST_REJECTED event when circuit is OPEN', async () => {
+      const events: CircuitBreakerEvent[] = []
+      const cb = new CircuitBreaker({
+        failureThreshold: 1,
+        onEvent: (event) => events.push(event),
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+
+      try {
+        await cb.execute(instanceId, vi.fn())
+      } catch {
+        // Expected
+      }
+
+      const rejectedEvent = events.find(e => e.type === 'REQUEST_REJECTED')
+      expect(rejectedEvent).toBeDefined()
+    })
+
+    it('should use fallback when circuit is OPEN and fallback provided', async () => {
+      const cb = new CircuitBreaker({
+        failureThreshold: 1,
+        fallback: async <T>() => 'fallback-value' as T,
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+
+      const result = await cb.execute(instanceId, vi.fn())
+      expect(result).toBe('fallback-value')
+    })
+
+    it('should track rejected requests in stats', async () => {
+      const cb = new CircuitBreaker({ failureThreshold: 1 })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+
+      try {
+        await cb.execute(instanceId, vi.fn())
+      } catch {
+        // Expected
+      }
+
+      const stats = cb.getStats(instanceId)
+      expect(stats.totalRejected).toBe(1)
+    })
+  })
+
+  describe('getStats()', () => {
+    it('should return correct statistics', () => {
+      const cb = new CircuitBreaker({ failureThreshold: 3 })
+      const instanceId = 'test-instance'
+
+      cb.recordSuccess(instanceId)
+      cb.recordSuccess(instanceId)
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+
+      const stats = cb.getStats(instanceId)
+
+      expect(stats.state).toBe('CLOSED')
+      expect(stats.totalSuccesses).toBe(2)
+      expect(stats.totalFailures).toBe(2)
+      expect(stats.totalRequests).toBe(4)
+      expect(stats.failureCount).toBe(2)
+      expect(stats.lastSuccessTime).not.toBeNull()
+      expect(stats.lastFailureTime).not.toBeNull()
+    })
+  })
+
+  describe('getAllStats()', () => {
+    it('should return stats for all instances', () => {
+      const cb = new CircuitBreaker()
+
+      cb.recordSuccess('instance-1')
+      cb.recordFailure('instance-2')
+      cb.recordSuccess('instance-3')
+
+      const allStats = cb.getAllStats()
+
+      expect(allStats.size).toBe(3)
+      expect(allStats.has('instance-1')).toBe(true)
+      expect(allStats.has('instance-2')).toBe(true)
+      expect(allStats.has('instance-3')).toBe(true)
+    })
+  })
+
+  describe('reset()', () => {
+    it('should reset circuit to CLOSED state', () => {
+      const cb = new CircuitBreaker({ failureThreshold: 2 })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+
+      expect(cb.getState(instanceId)).toBe('OPEN')
+
+      cb.reset(instanceId)
+
+      expect(cb.getState(instanceId)).toBe('CLOSED')
+    })
+
+    it('should clear failure count on reset', () => {
+      const cb = new CircuitBreaker({ failureThreshold: 5 })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+
+      cb.reset(instanceId)
+
+      const stats = cb.getStats(instanceId)
+      expect(stats.failureCount).toBe(0)
+    })
+
+    it('should emit STATE_CHANGE event on reset', () => {
+      const events: CircuitBreakerEvent[] = []
+      const cb = new CircuitBreaker({
+        failureThreshold: 1,
+        onEvent: (event) => events.push(event),
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.reset(instanceId)
+
+      const stateChange = events.filter(e => e.type === 'STATE_CHANGE').pop()
+      expect(stateChange).toBeDefined()
+      if (stateChange?.type === 'STATE_CHANGE') {
+        expect(stateChange.from).toBe('OPEN')
+        expect(stateChange.to).toBe('CLOSED')
+      }
+    })
+  })
+
+  describe('forceOpen()', () => {
+    it('should force circuit to OPEN state', () => {
+      const cb = new CircuitBreaker()
+      const instanceId = 'test-instance'
+
+      expect(cb.getState(instanceId)).toBe('CLOSED')
+
+      cb.forceOpen(instanceId)
+
+      expect(cb.getState(instanceId)).toBe('OPEN')
+    })
+
+    it('should emit STATE_CHANGE event', () => {
+      const events: CircuitBreakerEvent[] = []
+      const cb = new CircuitBreaker({
+        onEvent: (event) => events.push(event),
+      })
+      const instanceId = 'test-instance'
+
+      cb.forceOpen(instanceId)
+
+      const stateChange = events.find(e => e.type === 'STATE_CHANGE')
+      expect(stateChange).toBeDefined()
+      if (stateChange?.type === 'STATE_CHANGE') {
+        expect(stateChange.from).toBe('CLOSED')
+        expect(stateChange.to).toBe('OPEN')
+      }
+    })
+  })
+
+  describe('remove()', () => {
+    it('should remove instance tracking', () => {
+      const cb = new CircuitBreaker()
+      const instanceId = 'test-instance'
+
+      cb.recordSuccess(instanceId)
+      expect(cb.getAllStats().has(instanceId)).toBe(true)
+
+      const removed = cb.remove(instanceId)
+
+      expect(removed).toBe(true)
+      expect(cb.getAllStats().has(instanceId)).toBe(false)
+    })
+
+    it('should return false for non-existent instance', () => {
+      const cb = new CircuitBreaker()
+      const removed = cb.remove('non-existent')
+      expect(removed).toBe(false)
+    })
+  })
+
+  describe('clear()', () => {
+    it('should clear all instance tracking', () => {
+      const cb = new CircuitBreaker()
+
+      cb.recordSuccess('instance-1')
+      cb.recordSuccess('instance-2')
+      cb.recordSuccess('instance-3')
+
+      expect(cb.getAllStats().size).toBe(3)
+
+      cb.clear()
+
+      expect(cb.getAllStats().size).toBe(0)
+    })
+  })
+
+  describe('multiple instances', () => {
+    it('should track state independently per instance', () => {
+      const cb = new CircuitBreaker({ failureThreshold: 2 })
+
+      cb.recordFailure('instance-1')
+      cb.recordFailure('instance-1')
+
+      cb.recordSuccess('instance-2')
+
+      expect(cb.getState('instance-1')).toBe('OPEN')
+      expect(cb.getState('instance-2')).toBe('CLOSED')
+    })
+
+    it('should allow execution on healthy instances when others are open', async () => {
+      const cb = new CircuitBreaker({ failureThreshold: 1 })
+
+      cb.recordFailure('unhealthy')
+
+      const fn = vi.fn().mockResolvedValue('success')
+
+      // Should throw for unhealthy instance
+      await expect(cb.execute('unhealthy', fn)).rejects.toThrow(CircuitOpenError)
+      expect(fn).not.toHaveBeenCalled()
+
+      // Should succeed for healthy instance
+      const result = await cb.execute('healthy', fn)
+      expect(fn).toHaveBeenCalled()
+      expect(result).toBe('success')
+    })
+  })
+})
+
+describe('DOCircuitBreakerWrapper', () => {
+  const createMockStub = (handler: (request: Request) => Promise<Response>): DOStub => ({
+    fetch: handler,
+  })
+
+  describe('wrap()', () => {
+    it('should pass requests through when circuit is CLOSED', async () => {
+      const wrapper = new DOCircuitBreakerWrapper()
+      const mockResponse = new Response('OK', { status: 200 })
+      const stub = createMockStub(async () => mockResponse)
+
+      const wrappedStub = wrapper.wrap(stub, 'test-do')
+      const request = new Request('http://localhost/test')
+
+      const response = await wrappedStub.fetch(request)
+
+      expect(response.status).toBe(200)
+    })
+
+    it('should record success for 2xx responses', async () => {
+      const wrapper = new DOCircuitBreakerWrapper()
+      const stub = createMockStub(async () => new Response('OK', { status: 200 }))
+
+      const wrappedStub = wrapper.wrap(stub, 'test-do')
+      const request = new Request('http://localhost/test')
+
+      await wrappedStub.fetch(request)
+
+      const stats = wrapper.getStats('test-do')
+      expect(stats.totalSuccesses).toBe(1)
+    })
+
+    it('should record failure for 5xx responses', async () => {
+      const wrapper = new DOCircuitBreakerWrapper()
+      const stub = createMockStub(async () => new Response('Error', { status: 500 }))
+
+      const wrappedStub = wrapper.wrap(stub, 'test-do')
+      const request = new Request('http://localhost/test')
+
+      await expect(wrappedStub.fetch(request)).rejects.toThrow()
+
+      const stats = wrapper.getStats('test-do')
+      expect(stats.totalFailures).toBe(1)
+    })
+
+    it('should not treat 4xx as failures', async () => {
+      const wrapper = new DOCircuitBreakerWrapper()
+      const stub = createMockStub(async () => new Response('Not Found', { status: 404 }))
+
+      const wrappedStub = wrapper.wrap(stub, 'test-do')
+      const request = new Request('http://localhost/test')
+
+      const response = await wrappedStub.fetch(request)
+
+      expect(response.status).toBe(404)
+
+      const stats = wrapper.getStats('test-do')
+      expect(stats.totalSuccesses).toBe(1)
+      expect(stats.totalFailures).toBe(0)
+    })
+
+    it('should open circuit after failure threshold', async () => {
+      const wrapper = new DOCircuitBreakerWrapper({
+        failureThreshold: 2,
+      })
+      const stub = createMockStub(async () => new Response('Error', { status: 500 }))
+
+      const wrappedStub = wrapper.wrap(stub, 'test-do')
+      const request = new Request('http://localhost/test')
+
+      await expect(wrappedStub.fetch(request)).rejects.toThrow()
+      await expect(wrappedStub.fetch(request)).rejects.toThrow()
+
+      expect(wrapper.getState('test-do')).toBe('OPEN')
+    })
+
+    it('should throw CircuitOpenError when circuit is OPEN', async () => {
+      const wrapper = new DOCircuitBreakerWrapper({
+        failureThreshold: 1,
+      })
+      const stub = createMockStub(async () => new Response('Error', { status: 500 }))
+
+      const wrappedStub = wrapper.wrap(stub, 'test-do')
+      const request = new Request('http://localhost/test')
+
+      await expect(wrappedStub.fetch(request)).rejects.toThrow()
+      await expect(wrappedStub.fetch(request)).rejects.toThrow(CircuitOpenError)
+    })
+
+    it('should use fallbackResponse when circuit is OPEN', async () => {
+      const wrapper = new DOCircuitBreakerWrapper({
+        failureThreshold: 1,
+        fallbackResponse: () => new Response('Fallback', { status: 503 }),
+      })
+      const stub = createMockStub(async () => new Response('Error', { status: 500 }))
+
+      const wrappedStub = wrapper.wrap(stub, 'test-do')
+      const request = new Request('http://localhost/test')
+
+      await expect(wrappedStub.fetch(request)).rejects.toThrow()
+
+      const response = await wrappedStub.fetch(request)
+      expect(response.status).toBe(503)
+      expect(await response.text()).toBe('Fallback')
+    })
+
+    it('should use custom isFailure function', async () => {
+      const wrapper = new DOCircuitBreakerWrapper({
+        failureThreshold: 1,
+        isFailure: (response) => response.status === 429, // Rate limited
+      })
+
+      const calls: number[] = []
+      const stub = createMockStub(async () => {
+        calls.push(1)
+        return new Response('Rate Limited', { status: 429 })
+      })
+
+      const wrappedStub = wrapper.wrap(stub, 'test-do')
+      const request = new Request('http://localhost/test')
+
+      await expect(wrappedStub.fetch(request)).rejects.toThrow()
+
+      expect(wrapper.getState('test-do')).toBe('OPEN')
+    })
+
+    it('should use custom getInstanceId function', async () => {
+      const wrapper = new DOCircuitBreakerWrapper({
+        getInstanceId: (req) => new URL(req.url).searchParams.get('db') || 'default',
+      })
+      const stub = createMockStub(async () => new Response('OK', { status: 200 }))
+
+      const wrappedStub = wrapper.wrap(stub)
+      const request1 = new Request('http://localhost/test?db=primary')
+      const request2 = new Request('http://localhost/test?db=replica')
+
+      await wrappedStub.fetch(request1)
+      await wrappedStub.fetch(request2)
+
+      expect(wrapper.getStats('primary').totalRequests).toBe(1)
+      expect(wrapper.getStats('replica').totalRequests).toBe(1)
+    })
+  })
+
+  describe('fetch()', () => {
+    it('should execute fetch with circuit breaker protection', async () => {
+      const wrapper = new DOCircuitBreakerWrapper()
+      const stub = createMockStub(async () => new Response('OK', { status: 200 }))
+      const request = new Request('http://localhost/test')
+
+      const response = await wrapper.fetch(stub, request, 'test-do')
+
+      expect(response.status).toBe(200)
+      expect(wrapper.getStats('test-do').totalSuccesses).toBe(1)
+    })
+  })
+
+  describe('getCircuitBreaker()', () => {
+    it('should return underlying circuit breaker', () => {
+      const wrapper = new DOCircuitBreakerWrapper()
+      const cb = wrapper.getCircuitBreaker()
+
+      expect(cb).toBeInstanceOf(CircuitBreaker)
+    })
+  })
+
+  describe('reset()', () => {
+    it('should reset circuit for instance', async () => {
+      const wrapper = new DOCircuitBreakerWrapper({ failureThreshold: 1 })
+      const stub = createMockStub(async () => new Response('Error', { status: 500 }))
+
+      const wrappedStub = wrapper.wrap(stub, 'test-do')
+      const request = new Request('http://localhost/test')
+
+      await expect(wrappedStub.fetch(request)).rejects.toThrow()
+      expect(wrapper.getState('test-do')).toBe('OPEN')
+
+      wrapper.reset('test-do')
+      expect(wrapper.getState('test-do')).toBe('CLOSED')
+    })
+  })
+
+  describe('forceOpen()', () => {
+    it('should force circuit open for instance', () => {
+      const wrapper = new DOCircuitBreakerWrapper()
+
+      wrapper.forceOpen('test-do')
+
+      expect(wrapper.getState('test-do')).toBe('OPEN')
+    })
+  })
+
+  describe('getAllStats()', () => {
+    it('should return stats for all tracked DO instances', async () => {
+      const wrapper = new DOCircuitBreakerWrapper()
+      const stub = createMockStub(async () => new Response('OK', { status: 200 }))
+
+      await wrapper.fetch(stub, new Request('http://localhost/test'), 'do-1')
+      await wrapper.fetch(stub, new Request('http://localhost/test'), 'do-2')
+      await wrapper.fetch(stub, new Request('http://localhost/test'), 'do-3')
+
+      const stats = wrapper.getAllStats()
+
+      expect(stats.size).toBe(3)
+    })
+  })
+
+  describe('event emission', () => {
+    it('should emit events through configuration', async () => {
+      const events: CircuitBreakerEvent[] = []
+      const wrapper = new DOCircuitBreakerWrapper({
+        failureThreshold: 1,
+        onEvent: (event) => events.push(event),
+      })
+
+      const stub = createMockStub(async () => new Response('Error', { status: 500 }))
+      const request = new Request('http://localhost/test')
+
+      try {
+        await wrapper.fetch(stub, request, 'test-do')
+      } catch {
+        // Expected
+      }
+
+      expect(events.some(e => e.type === 'FAILURE_RECORDED')).toBe(true)
+      expect(events.some(e => e.type === 'STATE_CHANGE')).toBe(true)
+    })
+  })
+})
+
+describe('CircuitOpenError', () => {
+  it('should have correct properties', () => {
+    const error = new CircuitOpenError('test-instance', 'OPEN', 5000)
+
+    expect(error.name).toBe('CircuitOpenError')
+    expect(error.instanceId).toBe('test-instance')
+    expect(error.state).toBe('OPEN')
+    expect(error.retryAfterMs).toBe(5000)
+    expect(error.message).toContain('test-instance')
+    expect(error.message).toContain('5000ms')
+  })
+})
+
+describe('Exponential Backoff', () => {
+  describe('configuration', () => {
+    it('should enable exponential backoff by default', () => {
+      const cb = new CircuitBreaker()
+      const config = cb.getConfig()
+
+      expect(config.enableExponentialBackoff).toBe(true)
+      expect(config.backoffMultiplier).toBe(2)
+      expect(config.maxResetTimeoutMs).toBe(300000)
+    })
+
+    it('should accept custom backoff configuration', () => {
+      const cb = new CircuitBreaker({
+        enableExponentialBackoff: true,
+        backoffMultiplier: 3,
+        maxResetTimeoutMs: 60000,
+      })
+      const config = cb.getConfig()
+
+      expect(config.enableExponentialBackoff).toBe(true)
+      expect(config.backoffMultiplier).toBe(3)
+      expect(config.maxResetTimeoutMs).toBe(60000)
+    })
+
+    it('should allow disabling exponential backoff', () => {
+      const cb = new CircuitBreaker({
+        enableExponentialBackoff: false,
+      })
+      const config = cb.getConfig()
+
+      expect(config.enableExponentialBackoff).toBe(false)
+    })
+  })
+
+  describe('backoff timeout calculation', () => {
+    it('should use base timeout on first circuit open', () => {
+      const cb = new CircuitBreaker({
+        failureThreshold: 2,
+        resetTimeoutMs: 1000,
+        enableExponentialBackoff: true,
+      })
+      const instanceId = 'test-instance'
+
+      cb.recordFailure(instanceId)
+      cb.recordFailure(instanceId)
+
+      const stats = cb.getStats(instanceId)
+      expect(stats.consecutiveOpens).toBe(1)
+      expect(stats.currentResetTimeoutMs).toBe(1000)
+    })
+
+    it('should double timeout on second consecutive circuit open', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 1,
+        resetTimeoutMs: 1000,
+        halfOpenSuccessThreshold: 1,
+        enableExponentialBackoff: true,
+        backoffMultiplier: 2,
+      })
+      const instanceId = 'test-instance'
+
+      // First open
+      cb.recordFailure(instanceId)
+      expect(cb.getState(instanceId)).toBe('OPEN')
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(1000)
+
+      // Move to HALF_OPEN
+      vi.advanceTimersByTime(1001)
+      expect(cb.getState(instanceId)).toBe('HALF_OPEN')
+
+      // Fail again -> second open with backoff
+      cb.recordFailure(instanceId)
+      expect(cb.getState(instanceId)).toBe('OPEN')
+      expect(cb.getStats(instanceId).consecutiveOpens).toBe(2)
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(2000) // 1000 * 2^1
+
+      vi.useRealTimers()
+    })
+
+    it('should apply exponential backoff correctly over multiple reopens', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 1,
+        resetTimeoutMs: 1000,
+        halfOpenSuccessThreshold: 1,
+        enableExponentialBackoff: true,
+        backoffMultiplier: 2,
+        maxResetTimeoutMs: 100000,
+      })
+      const instanceId = 'test-instance'
+
+      // First open: timeout = 1000ms
+      cb.recordFailure(instanceId)
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(1000)
+      vi.advanceTimersByTime(1001)
+      cb.getState(instanceId)
+
+      // Second open: timeout = 2000ms (1000 * 2^1)
+      cb.recordFailure(instanceId)
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(2000)
+      vi.advanceTimersByTime(2001)
+      cb.getState(instanceId)
+
+      // Third open: timeout = 4000ms (1000 * 2^2)
+      cb.recordFailure(instanceId)
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(4000)
+      vi.advanceTimersByTime(4001)
+      cb.getState(instanceId)
+
+      // Fourth open: timeout = 8000ms (1000 * 2^3)
+      cb.recordFailure(instanceId)
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(8000)
+
+      vi.useRealTimers()
+    })
+
+    it('should cap timeout at maxResetTimeoutMs', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 1,
+        resetTimeoutMs: 1000,
+        halfOpenSuccessThreshold: 1,
+        enableExponentialBackoff: true,
+        backoffMultiplier: 10,
+        maxResetTimeoutMs: 5000,
+      })
+      const instanceId = 'test-instance'
+
+      // First open: 1000ms
+      cb.recordFailure(instanceId)
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(1000)
+      vi.advanceTimersByTime(1001)
+      cb.getState(instanceId)
+
+      // Second open: would be 10000ms, but capped at 5000ms
+      cb.recordFailure(instanceId)
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(5000)
+
+      vi.useRealTimers()
+    })
+
+    it('should not apply backoff when disabled', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 1,
+        resetTimeoutMs: 1000,
+        halfOpenSuccessThreshold: 1,
+        enableExponentialBackoff: false,
+      })
+      const instanceId = 'test-instance'
+
+      // First open
+      cb.recordFailure(instanceId)
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(1000)
+      vi.advanceTimersByTime(1001)
+      cb.getState(instanceId)
+
+      // Second open - should still be 1000ms (no backoff)
+      cb.recordFailure(instanceId)
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(1000)
+
+      vi.useRealTimers()
+    })
+  })
+
+  describe('backoff reset on successful recovery', () => {
+    it('should reset consecutive opens and timeout on successful recovery', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 1,
+        resetTimeoutMs: 1000,
+        halfOpenSuccessThreshold: 1,
+        enableExponentialBackoff: true,
+        backoffMultiplier: 2,
+      })
+      const instanceId = 'test-instance'
+
+      // Open circuit multiple times to increase backoff
+      cb.recordFailure(instanceId)
+      vi.advanceTimersByTime(1001)
+      cb.getState(instanceId)
+      cb.recordFailure(instanceId)
+      vi.advanceTimersByTime(2001)
+      cb.getState(instanceId)
+      cb.recordFailure(instanceId)
+
+      expect(cb.getStats(instanceId).consecutiveOpens).toBe(3)
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(4000)
+
+      // Move to HALF_OPEN
+      vi.advanceTimersByTime(4001)
+      expect(cb.getState(instanceId)).toBe('HALF_OPEN')
+
+      // Successfully recover
+      cb.recordSuccess(instanceId)
+      expect(cb.getState(instanceId)).toBe('CLOSED')
+
+      // Consecutive opens and timeout should be reset
+      expect(cb.getStats(instanceId).consecutiveOpens).toBe(0)
+      expect(cb.getStats(instanceId).currentResetTimeoutMs).toBe(1000)
+
+      vi.useRealTimers()
+    })
+  })
+
+  describe('retry after calculation with backoff', () => {
+    it('should include backoff timeout in CircuitOpenError retryAfterMs', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 1,
+        resetTimeoutMs: 1000,
+        halfOpenSuccessThreshold: 1,
+        enableExponentialBackoff: true,
+        backoffMultiplier: 2,
+      })
+      const instanceId = 'test-instance'
+
+      // First open
+      cb.recordFailure(instanceId)
+      vi.advanceTimersByTime(1001)
+      cb.getState(instanceId)
+
+      // Second open with 2000ms timeout
+      cb.recordFailure(instanceId)
+
+      // Advance 500ms into the open period
+      vi.advanceTimersByTime(500)
+
+      try {
+        await cb.execute(instanceId, vi.fn())
+        expect.fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(CircuitOpenError)
+        if (error instanceof CircuitOpenError) {
+          // Should be approximately 1500ms remaining (2000ms - 500ms)
+          expect(error.retryAfterMs).toBeCloseTo(1500, -2)
+        }
+      }
+
+      vi.useRealTimers()
+    })
+  })
+
+  describe('HALF_OPEN timeout respects backoff', () => {
+    it('should wait for backoff timeout before transitioning to HALF_OPEN', async () => {
+      vi.useFakeTimers()
+
+      const cb = new CircuitBreaker({
+        failureThreshold: 1,
+        resetTimeoutMs: 1000,
+        halfOpenSuccessThreshold: 1,
+        enableExponentialBackoff: true,
+        backoffMultiplier: 2,
+      })
+      const instanceId = 'test-instance'
+
+      // First open
+      cb.recordFailure(instanceId)
+      vi.advanceTimersByTime(1001)
+      cb.getState(instanceId) // HALF_OPEN
+
+      // Second open with 2000ms timeout
+      cb.recordFailure(instanceId)
+
+      // Should still be OPEN after 1000ms
+      vi.advanceTimersByTime(1000)
+      expect(cb.getState(instanceId)).toBe('OPEN')
+
+      // Should still be OPEN at 1999ms
+      vi.advanceTimersByTime(999)
+      expect(cb.getState(instanceId)).toBe('OPEN')
+
+      // Should transition to HALF_OPEN after 2000ms
+      vi.advanceTimersByTime(2)
+      expect(cb.getState(instanceId)).toBe('HALF_OPEN')
+
+      vi.useRealTimers()
+    })
+  })
+})
+
+describe('DefaultMetricsCollector', () => {
+  describe('basic operations', () => {
+    it('should record state transitions', () => {
+      const collector = new DefaultMetricsCollector()
+
+      collector.recordStateTransition('instance-1', 'CLOSED', 'OPEN')
+      collector.recordStateTransition('instance-2', 'CLOSED', 'OPEN')
+      collector.recordStateTransition('instance-1', 'OPEN', 'HALF_OPEN')
+
+      const summary = collector.getSummary()
+      expect(summary.totalInstances).toBe(2)
+      expect(summary.openCircuits).toBe(1)
+      expect(summary.halfOpenCircuits).toBe(1)
+    })
+
+    it('should record failures', () => {
+      const collector = new DefaultMetricsCollector()
+
+      collector.recordFailure('instance-1', 1)
+      collector.recordFailure('instance-1', 2)
+      collector.recordFailure('instance-2', 1)
+
+      const summary = collector.getSummary()
+      expect(summary.totalFailures).toBe(3)
+    })
+
+    it('should record successes', () => {
+      const collector = new DefaultMetricsCollector()
+
+      collector.recordSuccess('instance-1')
+      collector.recordSuccess('instance-1')
+      collector.recordSuccess('instance-2')
+
+      const summary = collector.getSummary()
+      expect(summary.totalSuccesses).toBe(3)
+    })
+
+    it('should record rejections', () => {
+      const collector = new DefaultMetricsCollector()
+
+      collector.recordRejection('instance-1')
+      collector.recordRejection('instance-1')
+
+      const summary = collector.getSummary()
+      expect(summary.totalRejections).toBe(2)
+    })
+
+    it('should record backoff timeouts', () => {
+      const collector = new DefaultMetricsCollector()
+
+      collector.recordBackoffTimeout('instance-1', 1000)
+      collector.recordBackoffTimeout('instance-2', 2000)
+      collector.recordBackoffTimeout('instance-3', 3000)
+
+      const summary = collector.getSummary()
+      expect(summary.averageBackoffMs).toBe(2000)
+    })
+
+    it('should track circuit state counts correctly', () => {
+      const collector = new DefaultMetricsCollector()
+
+      // Create various states
+      collector.recordStateTransition('instance-1', 'CLOSED', 'OPEN')
+      collector.recordStateTransition('instance-2', 'CLOSED', 'OPEN')
+      collector.recordStateTransition('instance-3', 'CLOSED', 'HALF_OPEN')
+      collector.recordStateTransition('instance-4', 'OPEN', 'CLOSED')
+
+      const summary = collector.getSummary()
+      expect(summary.openCircuits).toBe(2)
+      expect(summary.halfOpenCircuits).toBe(1)
+      expect(summary.closedCircuits).toBe(1)
+    })
+  })
+
+  describe('getRecentTransitions()', () => {
+    it('should return recent state transitions', () => {
+      const collector = new DefaultMetricsCollector()
+
+      collector.recordStateTransition('instance-1', 'CLOSED', 'OPEN')
+      collector.recordStateTransition('instance-2', 'CLOSED', 'OPEN')
+      collector.recordStateTransition('instance-1', 'OPEN', 'HALF_OPEN')
+
+      const transitions = collector.getRecentTransitions()
+      expect(transitions).toHaveLength(3)
+      expect(transitions[0]!.from).toBe('CLOSED')
+      expect(transitions[0]!.to).toBe('OPEN')
+    })
+
+    it('should limit returned transitions', () => {
+      const collector = new DefaultMetricsCollector()
+
+      for (let i = 0; i < 10; i++) {
+        collector.recordStateTransition(`instance-${i}`, 'CLOSED', 'OPEN')
+      }
+
+      const transitions = collector.getRecentTransitions(5)
+      expect(transitions).toHaveLength(5)
+    })
+  })
+
+  describe('reset()', () => {
+    it('should clear all collected metrics', () => {
+      const collector = new DefaultMetricsCollector()
+
+      collector.recordStateTransition('instance-1', 'CLOSED', 'OPEN')
+      collector.recordFailure('instance-1', 1)
+      collector.recordSuccess('instance-2')
+      collector.recordRejection('instance-3')
+      collector.recordBackoffTimeout('instance-1', 1000)
+
+      collector.reset()
+
+      const summary = collector.getSummary()
+      expect(summary.totalInstances).toBe(0)
+      expect(summary.totalFailures).toBe(0)
+      expect(summary.totalSuccesses).toBe(0)
+      expect(summary.totalRejections).toBe(0)
+      expect(summary.averageBackoffMs).toBe(0)
+    })
+  })
+})
+
+describe('Metrics Integration', () => {
+  it('should report state transitions to metrics collector', () => {
+    const collector = new DefaultMetricsCollector()
+    const cb = new CircuitBreaker({
+      failureThreshold: 2,
+      metricsCollector: collector,
+    })
+
+    cb.recordFailure('test-instance')
+    cb.recordFailure('test-instance')
+
+    const summary = collector.getSummary()
+    expect(summary.openCircuits).toBe(1)
+  })
+
+  it('should report failures to metrics collector', () => {
+    const collector = new DefaultMetricsCollector()
+    const cb = new CircuitBreaker({
+      failureThreshold: 5,
+      metricsCollector: collector,
+    })
+
+    cb.recordFailure('test-instance')
+    cb.recordFailure('test-instance')
+
+    const summary = collector.getSummary()
+    expect(summary.totalFailures).toBe(2)
+  })
+
+  it('should report successes to metrics collector', () => {
+    const collector = new DefaultMetricsCollector()
+    const cb = new CircuitBreaker({
+      metricsCollector: collector,
+    })
+
+    cb.recordSuccess('test-instance')
+    cb.recordSuccess('test-instance')
+
+    const summary = collector.getSummary()
+    expect(summary.totalSuccesses).toBe(2)
+  })
+
+  it('should report rejections to metrics collector', async () => {
+    const collector = new DefaultMetricsCollector()
+    const cb = new CircuitBreaker({
+      failureThreshold: 1,
+      metricsCollector: collector,
+    })
+
+    cb.recordFailure('test-instance')
+
+    try {
+      await cb.execute('test-instance', vi.fn())
+    } catch {
+      // Expected
+    }
+
+    const summary = collector.getSummary()
+    expect(summary.totalRejections).toBe(1)
+  })
+
+  it('should report backoff timeouts to metrics collector', async () => {
+    vi.useFakeTimers()
+
+    const collector = new DefaultMetricsCollector()
+    const cb = new CircuitBreaker({
+      failureThreshold: 1,
+      resetTimeoutMs: 1000,
+      halfOpenSuccessThreshold: 1,
+      enableExponentialBackoff: true,
+      backoffMultiplier: 2,
+      metricsCollector: collector,
+    })
+
+    // First open: 1000ms timeout
+    cb.recordFailure('test-instance')
+    vi.advanceTimersByTime(1001)
+    cb.getState('test-instance')
+
+    // Second open: 2000ms timeout
+    cb.recordFailure('test-instance')
+
+    const summary = collector.getSummary()
+    expect(summary.averageBackoffMs).toBe(2000)
+
+    vi.useRealTimers()
+  })
+
+  it('should provide complete metrics through getAllStats and collector summary', async () => {
+    vi.useFakeTimers()
+
+    const collector = new DefaultMetricsCollector()
+    const cb = new CircuitBreaker({
+      failureThreshold: 2,
+      resetTimeoutMs: 1000,
+      halfOpenSuccessThreshold: 1,
+      metricsCollector: collector,
+    })
+
+    // Create various states across instances
+    cb.recordFailure('instance-1')
+    cb.recordFailure('instance-1') // Opens (CLOSED -> OPEN)
+    cb.recordFailure('instance-2')
+    cb.recordSuccess('instance-3')
+
+    vi.advanceTimersByTime(1001)
+    cb.getState('instance-1') // Moves to HALF_OPEN (OPEN -> HALF_OPEN)
+
+    const allStats = cb.getAllStats()
+    const collectorSummary = collector.getSummary()
+
+    // getAllStats tracks all instances that have been touched
+    expect(allStats.size).toBe(3)
+    // Metrics collector only tracks instances that had state changes
+    // instance-1 had state changes: CLOSED -> OPEN, OPEN -> HALF_OPEN
+    // instance-2 and instance-3 had no state changes (still CLOSED)
+    expect(collectorSummary.totalInstances).toBe(1) // Only instance-1 had state transitions
+    expect(collectorSummary.halfOpenCircuits).toBe(1)
+
+    vi.useRealTimers()
+  })
+})