@dotdo/postgres 0.1.0

package/src/observability/error-rate-collector.test.ts

@@ -0,0 +1,977 @@
+/**
+ * Tests for Error Rate Collector
+ *
+ * RED phase tests for postgres-ne18 [OBS-RED]
+ * These tests define the expected behavior for:
+ * 1. Time-windowed error rates (sliding window calculations)
+ * 2. Error categorization (grouping by type, code, severity)
+ * 3. Trend analysis (detecting spikes, patterns over time)
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'
+// These imports will fail until the implementation exists
+import {
+  ErrorRateCollector,
+  createErrorRateCollector,
+  ErrorCategory,
+  ErrorSeverity,
+  ErrorEvent,
+  ErrorRateSnapshot,
+  ErrorTrend,
+  TrendDirection,
+  type ErrorRateCollectorConfig,
+} from './error-rate-collector'
+
+describe('ErrorRateCollector', () => {
+  let collector: ErrorRateCollector
+
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date('2026-01-20T12:00:00.000Z'))
+    collector = createErrorRateCollector()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  // ==========================================================================
+  // 1. Time-Windowed Error Rates
+  // ==========================================================================
+
+  describe('Time-Windowed Error Rates', () => {
+    describe('Sliding Window Calculation', () => {
+      it('should calculate error rate within a 1-minute window', () => {
+        // Record 10 errors within 1 minute - spread backwards in time
+        for (let i = 0; i < 10; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Error ${i}`,
+            timestamp: Date.now() - i * 5000, // Every 5 seconds going back
+          })
+        }
+
+        const rate = collector.getErrorRate({ windowMs: 60_000 })
+        expect(rate.count).toBe(10)
+        expect(rate.ratePerMinute).toBe(10)
+        expect(rate.windowMs).toBe(60_000)
+      })
+
+      it('should calculate error rate within a 5-minute window', () => {
+        // Record 30 errors over 5 minutes (6 per minute) - spread backwards in time
+        for (let i = 0; i < 30; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Error ${i}`,
+            timestamp: Date.now() - i * 10000, // Every 10 seconds going back
+          })
+        }
+
+        const rate = collector.getErrorRate({ windowMs: 300_000 })
+        expect(rate.count).toBe(30)
+        expect(rate.ratePerMinute).toBe(6)
+        expect(rate.windowMs).toBe(300_000)
+      })
+
+      it('should exclude errors outside the window', () => {
+        // Record 5 errors in the past (outside window)
+        for (let i = 0; i < 5; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Old error ${i}`,
+            timestamp: Date.now() - 120_000 - i * 1000, // 2+ minutes ago
+          })
+        }
+
+        // Record 3 errors within the window
+        for (let i = 0; i < 3; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Recent error ${i}`,
+            timestamp: Date.now() - i * 1000, // Within last minute
+          })
+        }
+
+        const rate = collector.getErrorRate({ windowMs: 60_000 })
+        expect(rate.count).toBe(3)
+      })
+
+      it('should slide the window as time progresses', () => {
+        // Record errors at time 0
+        collector.recordError({ category: 'query', message: 'Error 1' })
+        collector.recordError({ category: 'query', message: 'Error 2' })
+
+        // Check initial rate
+        let rate = collector.getErrorRate({ windowMs: 60_000 })
+        expect(rate.count).toBe(2)
+
+        // Advance time by 30 seconds
+        vi.advanceTimersByTime(30_000)
+        collector.recordError({ category: 'query', message: 'Error 3' })
+
+        rate = collector.getErrorRate({ windowMs: 60_000 })
+        expect(rate.count).toBe(3)
+
+        // Advance time past the first errors
+        vi.advanceTimersByTime(31_000) // 61 seconds total
+
+        rate = collector.getErrorRate({ windowMs: 60_000 })
+        expect(rate.count).toBe(1) // Only Error 3 in window
+      })
+
+      it('should support configurable window sizes', () => {
+        collector = createErrorRateCollector({
+          defaultWindowMs: 30_000, // 30 second default
+        })
+
+        for (let i = 0; i < 6; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Error ${i}`,
+            timestamp: Date.now() - i * 5000, // Every 5 seconds
+          })
+        }
+
+        // Default window (30s) should include 6 errors
+        const defaultRate = collector.getErrorRate()
+        expect(defaultRate.count).toBe(6)
+
+        // Custom window (10s) should include errors at 0ms, 5s, 10s ago = 3 errors
+        // Errors at i=0 (0ms ago), i=1 (5s ago), i=2 (10s ago) are within 10s window
+        const customRate = collector.getErrorRate({ windowMs: 10_000 })
+        expect(customRate.count).toBe(3)
+      })
+    })
+
+    describe('Rate Calculations', () => {
+      it('should calculate errors per second', () => {
+        // Record 60 errors over 60 seconds
+        for (let i = 0; i < 60; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Error ${i}`,
+            timestamp: Date.now() - i * 1000,
+          })
+        }
+
+        const rate = collector.getErrorRate({ windowMs: 60_000 })
+        expect(rate.ratePerSecond).toBeCloseTo(1, 1)
+      })
+
+      it('should calculate errors per minute', () => {
+        // Record 120 errors over 2 minutes
+        for (let i = 0; i < 120; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Error ${i}`,
+            timestamp: Date.now() - i * 1000,
+          })
+        }
+
+        const rate = collector.getErrorRate({ windowMs: 120_000 })
+        expect(rate.ratePerMinute).toBeCloseTo(60, 1)
+      })
+
+      it('should calculate errors per hour', () => {
+        // Record 3600 errors over 1 hour
+        for (let i = 0; i < 100; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Error ${i}`,
+            timestamp: Date.now() - i * 36000, // Spread over an hour
+          })
+        }
+
+        const rate = collector.getErrorRate({ windowMs: 3600_000 })
+        expect(rate.ratePerHour).toBeDefined()
+      })
+
+      it('should handle zero errors gracefully', () => {
+        const rate = collector.getErrorRate({ windowMs: 60_000 })
+        expect(rate.count).toBe(0)
+        expect(rate.ratePerMinute).toBe(0)
+        expect(rate.ratePerSecond).toBe(0)
+      })
+    })
+
+    describe('Window Bucketing', () => {
+      it('should organize errors into time buckets', () => {
+        // Record errors in distinct time buckets
+        collector.recordError({
+          category: 'query',
+          message: 'Error in bucket 1',
+          timestamp: Date.now() - 5000,
+        })
+        collector.recordError({
+          category: 'query',
+          message: 'Error in bucket 2',
+          timestamp: Date.now() - 15000,
+        })
+        collector.recordError({
+          category: 'query',
+          message: 'Error in bucket 3',
+          timestamp: Date.now() - 25000,
+        })
+
+        const buckets = collector.getErrorBuckets({
+          windowMs: 60_000,
+          bucketSizeMs: 10_000,
+        })
+
+        expect(buckets).toHaveLength(6) // 60s / 10s = 6 buckets
+        expect(buckets[0].count).toBe(1) // Most recent bucket
+        expect(buckets[1].count).toBe(1) // Second bucket
+        expect(buckets[2].count).toBe(1) // Third bucket
+      })
+
+      it('should aggregate errors within the same bucket', () => {
+        // Record multiple errors in the same 10-second bucket
+        collector.recordError({ category: 'query', message: 'E1', timestamp: Date.now() - 1000 })
+        collector.recordError({ category: 'query', message: 'E2', timestamp: Date.now() - 2000 })
+        collector.recordError({ category: 'query', message: 'E3', timestamp: Date.now() - 3000 })
+
+        const buckets = collector.getErrorBuckets({
+          windowMs: 60_000,
+          bucketSizeMs: 10_000,
+        })
+
+        expect(buckets[0].count).toBe(3)
+      })
+    })
+  })
+
+  // ==========================================================================
+  // 2. Error Categorization
+  // ==========================================================================
+
+  describe('Error Categorization', () => {
+    describe('Category Classification', () => {
+      it('should categorize errors by type', () => {
+        collector.recordError({ category: 'query', message: 'SQL syntax error' })
+        collector.recordError({ category: 'connection', message: 'Connection refused' })
+        collector.recordError({ category: 'timeout', message: 'Query timeout' })
+        collector.recordError({ category: 'query', message: 'Foreign key violation' })
+
+        const byCategory = collector.getErrorsByCategory()
+
+        expect(byCategory['query'].count).toBe(2)
+        expect(byCategory['connection'].count).toBe(1)
+        expect(byCategory['timeout'].count).toBe(1)
+      })
+
+      it('should support all standard error categories', () => {
+        const categories: ErrorCategory[] = [
+          'query',
+          'connection',
+          'cache',
+          'storage',
+          'timeout',
+          'validation',
+          'authentication',
+          'authorization',
+          'rate_limit',
+          'internal',
+          'unknown',
+        ]
+
+        categories.forEach((category) => {
+          collector.recordError({ category, message: `${category} error` })
+        })
+
+        const byCategory = collector.getErrorsByCategory()
+
+        categories.forEach((category) => {
+          expect(byCategory[category]).toBeDefined()
+          expect(byCategory[category].count).toBe(1)
+        })
+      })
+
+      it('should calculate rate per category', () => {
+        // Record errors at different rates per category
+        for (let i = 0; i < 10; i++) {
+          collector.recordError({ category: 'query', message: 'Query error' })
+        }
+        for (let i = 0; i < 5; i++) {
+          collector.recordError({ category: 'timeout', message: 'Timeout' })
+        }
+        for (let i = 0; i < 2; i++) {
+          collector.recordError({ category: 'connection', message: 'Connection error' })
+        }
+
+        const byCategory = collector.getErrorsByCategory({ windowMs: 60_000 })
+
+        expect(byCategory['query'].ratePerMinute).toBe(10)
+        expect(byCategory['timeout'].ratePerMinute).toBe(5)
+        expect(byCategory['connection'].ratePerMinute).toBe(2)
+      })
+    })
+
+    describe('Error Code Grouping', () => {
+      it('should group errors by error code', () => {
+        collector.recordError({
+          category: 'query',
+          message: 'Syntax error',
+          code: '42601',
+        })
+        collector.recordError({
+          category: 'query',
+          message: 'Another syntax error',
+          code: '42601',
+        })
+        collector.recordError({
+          category: 'query',
+          message: 'Foreign key violation',
+          code: '23503',
+        })
+
+        const byCode = collector.getErrorsByCode()
+
+        expect(byCode['42601'].count).toBe(2)
+        expect(byCode['23503'].count).toBe(1)
+      })
+
+      it('should handle errors without codes', () => {
+        collector.recordError({ category: 'query', message: 'Error without code' })
+        collector.recordError({ category: 'query', message: 'Error with code', code: 'ERR001' })
+
+        const byCode = collector.getErrorsByCode()
+
+        expect(byCode['unknown']).toBeDefined()
+        expect(byCode['unknown'].count).toBe(1)
+        expect(byCode['ERR001'].count).toBe(1)
+      })
+
+      it('should track top error codes', () => {
+        for (let i = 0; i < 50; i++) {
+          collector.recordError({ category: 'query', message: 'Common error', code: 'ERR001' })
+        }
+        for (let i = 0; i < 30; i++) {
+          collector.recordError({ category: 'query', message: 'Less common', code: 'ERR002' })
+        }
+        for (let i = 0; i < 10; i++) {
+          collector.recordError({ category: 'query', message: 'Rare error', code: 'ERR003' })
+        }
+
+        const topCodes = collector.getTopErrorCodes({ limit: 2 })
+
+        expect(topCodes).toHaveLength(2)
+        expect(topCodes[0].code).toBe('ERR001')
+        expect(topCodes[0].count).toBe(50)
+        expect(topCodes[1].code).toBe('ERR002')
+        expect(topCodes[1].count).toBe(30)
+      })
+    })
+
+    describe('Severity Classification', () => {
+      it('should classify errors by severity', () => {
+        collector.recordError({
+          category: 'query',
+          message: 'Minor issue',
+          severity: 'warning',
+        })
+        collector.recordError({
+          category: 'connection',
+          message: 'Connection failed',
+          severity: 'error',
+        })
+        collector.recordError({
+          category: 'storage',
+          message: 'Storage exhausted',
+          severity: 'critical',
+        })
+
+        const bySeverity = collector.getErrorsBySeverity()
+
+        expect(bySeverity['warning'].count).toBe(1)
+        expect(bySeverity['error'].count).toBe(1)
+        expect(bySeverity['critical'].count).toBe(1)
+      })
+
+      it('should default to error severity when not specified', () => {
+        collector.recordError({ category: 'query', message: 'Default severity' })
+
+        const bySeverity = collector.getErrorsBySeverity()
+
+        expect(bySeverity['error'].count).toBe(1)
+      })
+
+      it('should support all severity levels', () => {
+        const severities: ErrorSeverity[] = ['debug', 'info', 'warning', 'error', 'critical']
+
+        severities.forEach((severity) => {
+          collector.recordError({
+            category: 'query',
+            message: `${severity} level error`,
+            severity,
+          })
+        })
+
+        const bySeverity = collector.getErrorsBySeverity()
+
+        severities.forEach((severity) => {
+          expect(bySeverity[severity]).toBeDefined()
+          expect(bySeverity[severity].count).toBe(1)
+        })
+      })
+    })
+
+    describe('Multi-Dimensional Filtering', () => {
+      it('should filter errors by category and time window', () => {
+        // Old query errors
+        collector.recordError({
+          category: 'query',
+          message: 'Old query error',
+          timestamp: Date.now() - 120_000,
+        })
+
+        // Recent query errors
+        collector.recordError({
+          category: 'query',
+          message: 'Recent query error',
+          timestamp: Date.now() - 10_000,
+        })
+
+        // Recent connection errors
+        collector.recordError({
+          category: 'connection',
+          message: 'Recent connection error',
+          timestamp: Date.now() - 10_000,
+        })
+
+        const queryErrors = collector.getErrorRate({
+          windowMs: 60_000,
+          category: 'query',
+        })
+
+        expect(queryErrors.count).toBe(1)
+      })
+
+      it('should filter errors by multiple criteria', () => {
+        collector.recordError({
+          category: 'query',
+          message: 'Critical query error',
+          severity: 'critical',
+          code: 'CRIT001',
+        })
+        collector.recordError({
+          category: 'query',
+          message: 'Normal query error',
+          severity: 'error',
+          code: 'ERR001',
+        })
+        collector.recordError({
+          category: 'connection',
+          message: 'Critical connection error',
+          severity: 'critical',
+          code: 'CRIT002',
+        })
+
+        const criticalQueryErrors = collector.getErrorRate({
+          category: 'query',
+          severity: 'critical',
+        })
+
+        expect(criticalQueryErrors.count).toBe(1)
+      })
+
+      it('should support tag-based filtering', () => {
+        collector.recordError({
+          category: 'query',
+          message: 'Error in database A',
+          tags: { database: 'db_a', operation: 'SELECT' },
+        })
+        collector.recordError({
+          category: 'query',
+          message: 'Error in database B',
+          tags: { database: 'db_b', operation: 'INSERT' },
+        })
+        collector.recordError({
+          category: 'query',
+          message: 'Another error in database A',
+          tags: { database: 'db_a', operation: 'UPDATE' },
+        })
+
+        const dbAErrors = collector.getErrorRate({
+          tags: { database: 'db_a' },
+        })
+
+        expect(dbAErrors.count).toBe(2)
+      })
+    })
+  })
+
+  // ==========================================================================
+  // 3. Trend Analysis
+  // ==========================================================================
+
+  describe('Trend Analysis', () => {
+    describe('Trend Detection', () => {
+      it('should detect increasing error trend', () => {
+        // Simulate increasing errors over time
+        // Window 1: 2 errors
+        collector.recordError({ category: 'query', message: 'E1', timestamp: Date.now() - 180_000 })
+        collector.recordError({ category: 'query', message: 'E2', timestamp: Date.now() - 170_000 })
+
+        // Window 2: 5 errors
+        for (let i = 0; i < 5; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `E${i + 3}`,
+            timestamp: Date.now() - 120_000 + i * 1000,
+          })
+        }
+
+        // Window 3: 10 errors
+        for (let i = 0; i < 10; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `E${i + 8}`,
+            timestamp: Date.now() - 60_000 + i * 1000,
+          })
+        }
+
+        // Window 4 (current): 15 errors
+        for (let i = 0; i < 15; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `E${i + 18}`,
+            timestamp: Date.now() - i * 1000,
+          })
+        }
+
+        const trend = collector.analyzeTrend({ windowMs: 60_000, periods: 4 })
+
+        expect(trend.direction).toBe('increasing' as TrendDirection)
+        expect(trend.changePercent).toBeGreaterThan(0)
+      })
+
+      it('should detect decreasing error trend', () => {
+        // Simulate decreasing errors over time
+        // Window 1: 20 errors
+        for (let i = 0; i < 20; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `E${i}`,
+            timestamp: Date.now() - 180_000 + i * 1000,
+          })
+        }
+
+        // Window 2: 10 errors
+        for (let i = 0; i < 10; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `E${i + 20}`,
+            timestamp: Date.now() - 120_000 + i * 1000,
+          })
+        }
+
+        // Window 3: 5 errors
+        for (let i = 0; i < 5; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `E${i + 30}`,
+            timestamp: Date.now() - 60_000 + i * 1000,
+          })
+        }
+
+        // Window 4 (current): 2 errors
+        collector.recordError({ category: 'query', message: 'E35', timestamp: Date.now() - 5000 })
+        collector.recordError({ category: 'query', message: 'E36', timestamp: Date.now() - 3000 })
+
+        const trend = collector.analyzeTrend({ windowMs: 60_000, periods: 4 })
+
+        expect(trend.direction).toBe('decreasing' as TrendDirection)
+        expect(trend.changePercent).toBeLessThan(0)
+      })
+
+      it('should detect stable error rate', () => {
+        // Simulate stable errors over time (~5 errors per window)
+        for (let window = 0; window < 4; window++) {
+          for (let i = 0; i < 5; i++) {
+            collector.recordError({
+              category: 'query',
+              message: `E${window * 5 + i}`,
+              timestamp: Date.now() - (3 - window) * 60_000 - i * 1000,
+            })
+          }
+        }
+
+        const trend = collector.analyzeTrend({ windowMs: 60_000, periods: 4 })
+
+        expect(trend.direction).toBe('stable' as TrendDirection)
+        // The implementation uses 50% threshold for increasing/decreasing
+        // Anything between -50% and +50% is considered stable
+        expect(Math.abs(trend.changePercent)).toBeLessThan(50)
+      })
+    })
+
+    describe('Spike Detection', () => {
+      it('should detect sudden error spikes', () => {
+        // Normal baseline: ~2 errors per minute for 5 minutes
+        for (let min = 5; min >= 1; min--) {
+          collector.recordError({
+            category: 'query',
+            message: 'Normal error 1',
+            timestamp: Date.now() - min * 60_000 - 10_000,
+          })
+          collector.recordError({
+            category: 'query',
+            message: 'Normal error 2',
+            timestamp: Date.now() - min * 60_000 - 20_000,
+          })
+        }
+
+        // Sudden spike: 50 errors in the last minute
+        for (let i = 0; i < 50; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Spike error ${i}`,
+            timestamp: Date.now() - i * 1000,
+          })
+        }
+
+        const spikes = collector.detectSpikes({
+          windowMs: 60_000,
+          threshold: 3.0, // 3x standard deviation
+        })
+
+        expect(spikes).toHaveLength(1)
+        // Due to bucket boundary conditions, count may be 49-50
+        expect(spikes[0].count).toBeGreaterThanOrEqual(49)
+        expect(spikes[0].multiplier).toBeGreaterThan(3)
+      })
+
+      it('should not flag normal variations as spikes', () => {
+        // Slight variations in error rate
+        for (let min = 0; min < 10; min++) {
+          const errorsThisMinute = 5 + Math.floor(Math.random() * 3) // 5-7 errors
+          for (let i = 0; i < errorsThisMinute; i++) {
+            collector.recordError({
+              category: 'query',
+              message: `Error ${min}-${i}`,
+              timestamp: Date.now() - min * 60_000 - i * 5000,
+            })
+          }
+        }
+
+        const spikes = collector.detectSpikes({
+          windowMs: 60_000,
+          threshold: 2.0,
+        })
+
+        expect(spikes).toHaveLength(0)
+      })
+
+      it('should detect multiple spikes in time series', () => {
+        // Create baseline with two distinct spikes
+        for (let hour = 5; hour >= 0; hour--) {
+          const baseTime = Date.now() - hour * 3600_000
+
+          if (hour === 3 || hour === 1) {
+            // Spike hours: 30 errors
+            for (let i = 0; i < 30; i++) {
+              collector.recordError({
+                category: 'query',
+                message: `Spike error ${hour}-${i}`,
+                timestamp: baseTime - i * 60_000,
+              })
+            }
+          } else {
+            // Normal hours: 3 errors
+            for (let i = 0; i < 3; i++) {
+              collector.recordError({
+                category: 'query',
+                message: `Normal error ${hour}-${i}`,
+                timestamp: baseTime - i * 60_000,
+              })
+            }
+          }
+        }
+
+        const spikes = collector.detectSpikes({
+          windowMs: 3600_000,
+          threshold: 2.0,
+        })
+
+        expect(spikes.length).toBeGreaterThanOrEqual(2)
+      })
+    })
+
+    describe('Rate Change Calculations', () => {
+      it('should calculate percentage change between periods', () => {
+        // Previous period: 10 errors
+        for (let i = 0; i < 10; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Previous ${i}`,
+            timestamp: Date.now() - 90_000 - i * 1000,
+          })
+        }
+
+        // Current period: 15 errors (50% increase)
+        for (let i = 0; i < 15; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Current ${i}`,
+            timestamp: Date.now() - i * 1000,
+          })
+        }
+
+        const change = collector.getRateChange({
+          currentWindowMs: 60_000,
+          previousWindowMs: 60_000,
+        })
+
+        expect(change.percentChange).toBeCloseTo(50, 0)
+        expect(change.currentRate).toBe(15)
+        expect(change.previousRate).toBe(10)
+      })
+
+      it('should handle zero previous rate', () => {
+        // No errors in previous period
+        // Current period: 5 errors
+        for (let i = 0; i < 5; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Current ${i}`,
+            timestamp: Date.now() - i * 1000,
+          })
+        }
+
+        const change = collector.getRateChange({
+          currentWindowMs: 60_000,
+          previousWindowMs: 60_000,
+        })
+
+        expect(change.previousRate).toBe(0)
+        expect(change.currentRate).toBe(5)
+        expect(change.percentChange).toBe(Infinity) // Or some sentinel value
+      })
+
+      it('should calculate moving average', () => {
+        // Create a series of error counts
+        const errorCounts = [5, 10, 8, 12, 15, 10, 8, 20, 10, 5]
+
+        errorCounts.forEach((count, minutesAgo) => {
+          for (let i = 0; i < count; i++) {
+            collector.recordError({
+              category: 'query',
+              message: `Error ${minutesAgo}-${i}`,
+              timestamp: Date.now() - (9 - minutesAgo) * 60_000 - i * 1000,
+            })
+          }
+        })
+
+        const movingAvg = collector.getMovingAverage({
+          windowMs: 60_000,
+          periods: 5,
+        })
+
+        expect(movingAvg).toBeDefined()
+        expect(movingAvg).toBeGreaterThan(0)
+        // Moving average of last 5 periods should be (10+8+20+10+5)/5 = 10.6
+        expect(movingAvg).toBeCloseTo(10.6, 0)
+      })
+    })
+
+    describe('Anomaly Detection', () => {
+      it('should identify anomalous error patterns', () => {
+        // Establish baseline: ~5 query errors, ~2 connection errors per minute
+        for (let min = 10; min >= 1; min--) {
+          for (let i = 0; i < 5; i++) {
+            collector.recordError({
+              category: 'query',
+              message: `Query error ${min}-${i}`,
+              timestamp: Date.now() - min * 60_000 - i * 5000,
+            })
+          }
+          for (let i = 0; i < 2; i++) {
+            collector.recordError({
+              category: 'connection',
+              message: `Connection error ${min}-${i}`,
+              timestamp: Date.now() - min * 60_000 - i * 5000,
+            })
+          }
+        }
+
+        // Current minute: unusual spike in connection errors
+        for (let i = 0; i < 20; i++) {
+          collector.recordError({
+            category: 'connection',
+            message: `Anomaly ${i}`,
+            timestamp: Date.now() - i * 1000,
+          })
+        }
+
+        const anomalies = collector.detectAnomalies({
+          windowMs: 60_000,
+          baselineWindowMs: 600_000,
+          sensitivity: 2.0,
+        })
+
+        expect(anomalies).toHaveLength(1)
+        expect(anomalies[0].category).toBe('connection')
+        expect(anomalies[0].severity).toBe('high')
+      })
+
+      it('should return no anomalies for normal patterns', () => {
+        // Consistent error rate
+        for (let min = 5; min >= 0; min--) {
+          for (let i = 0; i < 5; i++) {
+            collector.recordError({
+              category: 'query',
+              message: `Error ${min}-${i}`,
+              timestamp: Date.now() - min * 60_000 - i * 5000,
+            })
+          }
+        }
+
+        const anomalies = collector.detectAnomalies({
+          windowMs: 60_000,
+          baselineWindowMs: 300_000,
+          sensitivity: 2.0,
+        })
+
+        expect(anomalies).toHaveLength(0)
+      })
+    })
+
+    describe('Historical Comparison', () => {
+      it('should compare current rate to historical average', () => {
+        // Historical data: 40 errors spread over historical window
+        // Historical window: from 5 min ago to 1 min ago (4 min range)
+        for (let i = 0; i < 40; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Historical ${i}`,
+            // Spread evenly in the 4-minute range (61s to 299s ago)
+            timestamp: Date.now() - 61_000 - (i * 5000),
+          })
+        }
+
+        // Current: 20 errors in the current window (last minute)
+        for (let i = 0; i < 20; i++) {
+          collector.recordError({
+            category: 'query',
+            message: `Current ${i}`,
+            timestamp: Date.now() - i * 1000,
+          })
+        }
+
+        const comparison = collector.compareToHistorical({
+          currentWindowMs: 60_000,
+          historicalWindowMs: 300_000, // 5 minutes
+        })
+
+        expect(comparison.currentRate).toBe(20)
+        // Historical window: 4 minutes (5 min - 1 min) = 4 periods
+        // Historical avg = 40 errors / 4 periods = 10
+        expect(comparison.historicalAverage).toBeCloseTo(10, 0)
+        expect(comparison.ratio).toBeCloseTo(2, 0)
+      })
+    })
+  })
+
+  // ==========================================================================
+  // Integration and Edge Cases
+  // ==========================================================================
+
+  describe('Integration and Edge Cases', () => {
+    it('should handle high volume of errors efficiently', () => {
+      const startTime = Date.now()
+
+      // Record 10,000 errors
+      for (let i = 0; i < 10_000; i++) {
+        collector.recordError({
+          category: 'query',
+          message: `High volume error ${i}`,
+          timestamp: Date.now() - Math.random() * 60_000,
+        })
+      }
+
+      const elapsed = Date.now() - startTime
+
+      // Should complete in reasonable time (< 1 second)
+      expect(elapsed).toBeLessThan(1000)
+
+      const rate = collector.getErrorRate({ windowMs: 60_000 })
+      expect(rate.count).toBe(10_000)
+    })
+
+    it('should clean up old errors based on retention policy', () => {
+      collector = createErrorRateCollector({
+        retentionMs: 300_000, // 5 minute retention
+      })
+
+      // Record errors 10 minutes ago
+      for (let i = 0; i < 10; i++) {
+        collector.recordError({
+          category: 'query',
+          message: `Old error ${i}`,
+          timestamp: Date.now() - 600_000 - i * 1000,
+        })
+      }
+
+      // Record current errors
+      for (let i = 0; i < 5; i++) {
+        collector.recordError({
+          category: 'query',
+          message: `Current error ${i}`,
+          timestamp: Date.now() - i * 1000,
+        })
+      }
+
+      // Trigger cleanup
+      collector.cleanup()
+
+      const allErrors = collector.getErrorRate({ windowMs: 3600_000 })
+      expect(allErrors.count).toBe(5) // Only current errors remain
+    })
+
+    it('should provide thread-safe operations', async () => {
+      const promises: Promise<void>[] = []
+
+      // Simulate concurrent error recording
+      for (let i = 0; i < 100; i++) {
+        promises.push(
+          new Promise<void>((resolve) => {
+            collector.recordError({
+              category: 'query',
+              message: `Concurrent error ${i}`,
+            })
+            resolve()
+          })
+        )
+      }
+
+      await Promise.all(promises)
+
+      const rate = collector.getErrorRate({ windowMs: 60_000 })
+      expect(rate.count).toBe(100)
+    })
+
+    it('should export metrics snapshot', () => {
+      collector.recordError({ category: 'query', message: 'Error 1' })
+      collector.recordError({ category: 'connection', message: 'Error 2' })
+
+      const snapshot = collector.getSnapshot()
+
+      expect(snapshot.totalErrors).toBe(2)
+      expect(snapshot.byCategory).toBeDefined()
+      expect(snapshot.bySeverity).toBeDefined()
+      expect(snapshot.recentRate).toBeDefined()
+      expect(snapshot.timestamp).toBeDefined()
+    })
+
+    it('should reset all error data', () => {
+      for (let i = 0; i < 10; i++) {
+        collector.recordError({ category: 'query', message: `Error ${i}` })
+      }
+
+      collector.reset()
+
+      const rate = collector.getErrorRate({ windowMs: 60_000 })
+      expect(rate.count).toBe(0)
+    })
+  })
+})