@dotdo/postgres 0.1.0

package/src/observability/alerting.test.ts

@@ -0,0 +1,1133 @@
+/**
+ * Tests for Alerting System
+ *
+ * Tests threshold-based alerting with:
+ * - Threshold evaluation
+ * - Alert deduplication
+ * - Callback/webhook integration
+ * - Alert lifecycle (pending -> firing -> resolved)
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'
+import {
+  createAlertManager,
+  AlertManagerImpl,
+  AlertSeverity,
+  AlertState,
+  DEFAULT_ALERT_RULES,
+  createConsoleAlertHandler,
+  createWebhookAlertHandler,
+  createMetricsAlertHandler,
+} from './alerting'
+import type {
+  AlertRule,
+  Alert,
+  AlertNotification,
+  AlertHandler,
+  AlertingConfig,
+} from './alerting'
+import { createMetricsCollector } from './metrics'
+import type { MetricsCollector } from './types'
+
+describe('AlertManager', () => {
+  let metricsCollector: MetricsCollector
+  let alertManager: AlertManagerImpl
+
+  beforeEach(() => {
+    metricsCollector = createMetricsCollector()
+    alertManager = new AlertManagerImpl({
+      metricsCollector,
+      serviceName: 'test-service',
+      environment: 'test',
+    })
+  })
+
+  afterEach(() => {
+    alertManager.stop()
+  })
+
+  describe('createAlertManager()', () => {
+    it('should create an AlertManagerImpl instance', () => {
+      const manager = createAlertManager()
+      expect(manager).toBeInstanceOf(AlertManagerImpl)
+    })
+
+    it('should accept configuration options', () => {
+      const manager = createAlertManager({
+        serviceName: 'my-service',
+        environment: 'production',
+        evaluationIntervalMs: 5000,
+        repeatIntervalMs: 60000,
+      })
+      expect(manager).toBeInstanceOf(AlertManagerImpl)
+    })
+  })
+
+  describe('addRule() / removeRule()', () => {
+    it('should add an alert rule', () => {
+      const rule: AlertRule = {
+        name: 'TestRule',
+        description: 'Test alert rule',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+
+      // Rule exists when we evaluate
+      metricsCollector.gauge('test.metric', 150)
+      return alertManager.evaluate().then(alerts => {
+        expect(alerts.some(a => a.rule === 'TestRule')).toBe(true)
+      })
+    })
+
+    it('should remove an alert rule', () => {
+      const rule: AlertRule = {
+        name: 'RemoveMe',
+        description: 'Rule to be removed',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      alertManager.removeRule('RemoveMe')
+
+      metricsCollector.gauge('test.metric', 150)
+      return alertManager.evaluate().then(alerts => {
+        expect(alerts.some(a => a.rule === 'RemoveMe')).toBe(false)
+      })
+    })
+
+    it('should enable/disable rules', () => {
+      const rule: AlertRule = {
+        name: 'ToggleRule',
+        description: 'Rule to toggle',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      alertManager.setRuleEnabled('ToggleRule', false)
+
+      metricsCollector.gauge('test.metric', 150)
+      return alertManager.evaluate().then(alerts => {
+        expect(alerts.some(a => a.rule === 'ToggleRule')).toBe(false)
+      })
+    })
+  })
+
+  describe('Threshold Evaluation', () => {
+    it('should fire alert when value > threshold (gt)', async () => {
+      const rule: AlertRule = {
+        name: 'GTRule',
+        description: 'Greater than threshold',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      const alerts = await alertManager.evaluate()
+      const alert = alerts.find(a => a.rule === 'GTRule')
+
+      expect(alert).toBeDefined()
+      expect(alert?.state).toBe(AlertState.FIRING)
+      expect(alert?.value).toBe(150)
+      expect(alert?.threshold).toBe(100)
+    })
+
+    it('should not fire when value <= threshold (gt)', async () => {
+      const rule: AlertRule = {
+        name: 'GTRule',
+        description: 'Greater than threshold',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 100)
+
+      const alerts = await alertManager.evaluate()
+      const firingAlerts = alerts.filter(a => a.rule === 'GTRule' && a.state === AlertState.FIRING)
+      expect(firingAlerts).toHaveLength(0)
+    })
+
+    it('should fire alert when value >= threshold (gte)', async () => {
+      const rule: AlertRule = {
+        name: 'GTERule',
+        description: 'Greater than or equal threshold',
+        metric: 'test.metric',
+        operator: 'gte',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 100)
+
+      const alerts = await alertManager.evaluate()
+      const alert = alerts.find(a => a.rule === 'GTERule')
+
+      expect(alert).toBeDefined()
+      expect(alert?.state).toBe(AlertState.FIRING)
+    })
+
+    it('should fire alert when value < threshold (lt)', async () => {
+      const rule: AlertRule = {
+        name: 'LTRule',
+        description: 'Less than threshold',
+        metric: 'test.metric',
+        operator: 'lt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 50)
+
+      const alerts = await alertManager.evaluate()
+      const alert = alerts.find(a => a.rule === 'LTRule')
+
+      expect(alert).toBeDefined()
+      expect(alert?.state).toBe(AlertState.FIRING)
+    })
+
+    it('should fire alert when value <= threshold (lte)', async () => {
+      const rule: AlertRule = {
+        name: 'LTERule',
+        description: 'Less than or equal threshold',
+        metric: 'test.metric',
+        operator: 'lte',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 100)
+
+      const alerts = await alertManager.evaluate()
+      const alert = alerts.find(a => a.rule === 'LTERule')
+
+      expect(alert).toBeDefined()
+      expect(alert?.state).toBe(AlertState.FIRING)
+    })
+
+    it('should fire alert when value == threshold (eq)', async () => {
+      const rule: AlertRule = {
+        name: 'EQRule',
+        description: 'Equal to threshold',
+        metric: 'test.metric',
+        operator: 'eq',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 100)
+
+      const alerts = await alertManager.evaluate()
+      const alert = alerts.find(a => a.rule === 'EQRule')
+
+      expect(alert).toBeDefined()
+      expect(alert?.state).toBe(AlertState.FIRING)
+    })
+
+    it('should fire alert when value != threshold (ne)', async () => {
+      const rule: AlertRule = {
+        name: 'NERule',
+        description: 'Not equal to threshold',
+        metric: 'test.metric',
+        operator: 'ne',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      const alerts = await alertManager.evaluate()
+      const alert = alerts.find(a => a.rule === 'NERule')
+
+      expect(alert).toBeDefined()
+      expect(alert?.state).toBe(AlertState.FIRING)
+    })
+
+    it('should match metrics with tags', async () => {
+      const rule: AlertRule = {
+        name: 'TaggedRule',
+        description: 'Rule with tags',
+        metric: 'test.metric',
+        tags: { tier: 'hot' },
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 50, { tier: 'cold' })  // Different tag
+      metricsCollector.gauge('test.metric', 150, { tier: 'hot' })  // Matching tag
+
+      const alerts = await alertManager.evaluate()
+      const alert = alerts.find(a => a.rule === 'TaggedRule')
+
+      expect(alert).toBeDefined()
+      expect(alert?.value).toBe(150)
+    })
+  })
+
+  describe('Alert Lifecycle', () => {
+    it('should transition from pending to firing after forDuration', async () => {
+      vi.useFakeTimers()
+
+      const rule: AlertRule = {
+        name: 'DurationRule',
+        description: 'Rule with duration requirement',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+        forDurationMs: 5000,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      // First evaluation - should be pending or no alert yet
+      let alerts = await alertManager.evaluate()
+      let alert = alerts.find(a => a.rule === 'DurationRule')
+      // May be pending or not present yet
+      if (alert) {
+        expect([AlertState.PENDING, AlertState.FIRING]).toContain(alert.state)
+      }
+
+      // Advance time past forDuration
+      vi.advanceTimersByTime(6000)
+      metricsCollector.gauge('test.metric', 150)
+
+      alerts = await alertManager.evaluate()
+      alert = alerts.find(a => a.rule === 'DurationRule')
+
+      expect(alert).toBeDefined()
+      expect(alert?.state).toBe(AlertState.FIRING)
+
+      vi.useRealTimers()
+    })
+
+    it('should resolve alert when condition no longer met', async () => {
+      const rule: AlertRule = {
+        name: 'ResolveRule',
+        description: 'Rule to test resolution',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+
+      // Fire the alert
+      metricsCollector.gauge('test.metric', 150)
+      await alertManager.evaluate()
+
+      // Resolve by bringing value below threshold
+      metricsCollector.reset()
+      metricsCollector.gauge('test.metric', 50)
+      const alerts = await alertManager.evaluate()
+
+      const alert = alerts.find(a => a.rule === 'ResolveRule')
+      expect(alert?.state).toBe(AlertState.RESOLVED)
+    })
+
+    it('should track firing count and duration', async () => {
+      vi.useFakeTimers()
+
+      const rule: AlertRule = {
+        name: 'TrackingRule',
+        description: 'Rule to track counts',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      // First evaluation
+      await alertManager.evaluate()
+
+      // Advance time and evaluate again
+      vi.advanceTimersByTime(1000)
+      await alertManager.evaluate()
+
+      vi.advanceTimersByTime(1000)
+      const alerts = await alertManager.evaluate()
+
+      const alert = alerts.find(a => a.rule === 'TrackingRule')
+      expect(alert?.firingCount).toBeGreaterThanOrEqual(1)
+
+      vi.useRealTimers()
+    })
+  })
+
+  describe('Alert Deduplication', () => {
+    it('should not create duplicate alerts for same rule', async () => {
+      const handler = vi.fn()
+      alertManager.addHandler(handler)
+
+      const rule: AlertRule = {
+        name: 'DedupRule',
+        description: 'Deduplication test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      // Multiple evaluations
+      await alertManager.evaluate()
+      await alertManager.evaluate()
+      await alertManager.evaluate()
+
+      // Should only be notified once (first firing)
+      expect(handler).toHaveBeenCalledTimes(1)
+    })
+
+    it('should respect repeat interval for notifications', async () => {
+      vi.useFakeTimers()
+
+      const handler = vi.fn()
+      const manager = new AlertManagerImpl({
+        metricsCollector,
+        serviceName: 'test',
+        environment: 'test',
+        repeatIntervalMs: 5000,
+        handlers: [handler],
+      })
+
+      const rule: AlertRule = {
+        name: 'RepeatRule',
+        description: 'Repeat notification test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      manager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      // First notification
+      await manager.evaluate()
+      expect(handler).toHaveBeenCalledTimes(1)
+
+      // Before repeat interval
+      vi.advanceTimersByTime(3000)
+      await manager.evaluate()
+      expect(handler).toHaveBeenCalledTimes(1)
+
+      // After repeat interval
+      vi.advanceTimersByTime(3000)
+      await manager.evaluate()
+      expect(handler).toHaveBeenCalledTimes(2)
+
+      manager.stop()
+      vi.useRealTimers()
+    })
+
+    it('should not repeat if alert is acknowledged', async () => {
+      vi.useFakeTimers()
+
+      const handler = vi.fn()
+      const manager = new AlertManagerImpl({
+        metricsCollector,
+        serviceName: 'test',
+        environment: 'test',
+        repeatIntervalMs: 1000,
+        handlers: [handler],
+      })
+
+      const rule: AlertRule = {
+        name: 'AckRule',
+        description: 'Acknowledge test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      manager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      await manager.evaluate()
+      expect(handler).toHaveBeenCalledTimes(1)
+
+      // Acknowledge the alert
+      manager.acknowledge('AckRule')
+
+      // After repeat interval - should not notify due to ack
+      vi.advanceTimersByTime(2000)
+      await manager.evaluate()
+      expect(handler).toHaveBeenCalledTimes(1)
+
+      manager.stop()
+      vi.useRealTimers()
+    })
+  })
+
+  describe('Silencing', () => {
+    it('should silence alerts for specified duration', async () => {
+      vi.useFakeTimers()
+
+      const handler = vi.fn()
+      alertManager.addHandler(handler)
+
+      const rule: AlertRule = {
+        name: 'SilenceRule',
+        description: 'Silence test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+
+      // Silence for 5 seconds
+      alertManager.silence('SilenceRule', 5000)
+
+      metricsCollector.gauge('test.metric', 150)
+      await alertManager.evaluate()
+
+      // Should not fire while silenced
+      expect(handler).not.toHaveBeenCalled()
+
+      // After silence period
+      vi.advanceTimersByTime(6000)
+      await alertManager.evaluate()
+
+      expect(handler).toHaveBeenCalled()
+
+      vi.useRealTimers()
+    })
+  })
+
+  describe('Alert Handlers', () => {
+    it('should call registered handlers on alert', async () => {
+      const handler1 = vi.fn()
+      const handler2 = vi.fn()
+
+      alertManager.addHandler(handler1)
+      alertManager.addHandler(handler2)
+
+      const rule: AlertRule = {
+        name: 'HandlerRule',
+        description: 'Handler test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      await alertManager.evaluate()
+
+      expect(handler1).toHaveBeenCalled()
+      expect(handler2).toHaveBeenCalled()
+    })
+
+    it('should remove handlers', async () => {
+      const handler = vi.fn()
+      alertManager.addHandler(handler)
+      alertManager.removeHandler(handler)
+
+      const rule: AlertRule = {
+        name: 'RemoveHandlerRule',
+        description: 'Remove handler test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      await alertManager.evaluate()
+
+      expect(handler).not.toHaveBeenCalled()
+    })
+
+    it('should pass correct notification payload to handlers', async () => {
+      const handler = vi.fn()
+      alertManager.addHandler(handler)
+
+      const rule: AlertRule = {
+        name: 'PayloadRule',
+        description: 'Payload test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.CRITICAL,
+        labels: { team: 'platform' },
+        annotations: { runbook: 'https://example.com/runbook' },
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      await alertManager.evaluate()
+
+      expect(handler).toHaveBeenCalledWith(
+        expect.objectContaining({
+          service: 'test-service',
+          environment: 'test',
+          alert: expect.objectContaining({
+            rule: 'PayloadRule',
+            severity: AlertSeverity.CRITICAL,
+            value: 150,
+            threshold: 100,
+            labels: expect.objectContaining({ team: 'platform' }),
+            annotations: expect.objectContaining({ runbook: 'https://example.com/runbook' }),
+          }),
+        })
+      )
+    })
+
+    it('should handle async handlers', async () => {
+      const results: number[] = []
+
+      const asyncHandler: AlertHandler = async (notification) => {
+        await new Promise(resolve => setTimeout(resolve, 10))
+        results.push(1)
+      }
+
+      alertManager.addHandler(asyncHandler)
+
+      const rule: AlertRule = {
+        name: 'AsyncRule',
+        description: 'Async handler test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      await alertManager.evaluate()
+
+      expect(results).toContain(1)
+    })
+
+    it('should continue if one handler throws', async () => {
+      const errorHandler: AlertHandler = () => {
+        throw new Error('Handler error')
+      }
+      const successHandler = vi.fn()
+
+      alertManager.addHandler(errorHandler)
+      alertManager.addHandler(successHandler)
+
+      const rule: AlertRule = {
+        name: 'ErrorHandlerRule',
+        description: 'Error handler test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      await alertManager.evaluate()
+
+      // Second handler should still be called
+      expect(successHandler).toHaveBeenCalled()
+    })
+  })
+
+  describe('Built-in Alert Handlers', () => {
+    describe('createConsoleAlertHandler()', () => {
+      it('should log firing alerts', () => {
+        const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+        const handler = createConsoleAlertHandler()
+
+        const notification: AlertNotification = {
+          alert: {
+            rule: 'TestRule',
+            state: AlertState.FIRING,
+            severity: AlertSeverity.WARNING,
+            value: 150,
+            threshold: 100,
+            description: 'Test alert',
+            labels: {},
+            annotations: {},
+            firingCount: 1,
+          },
+          timestamp: Date.now(),
+          service: 'test-service',
+          environment: 'test',
+        }
+
+        handler(notification)
+
+        expect(consoleSpy).toHaveBeenCalledWith(
+          expect.stringContaining('[ALERT WARNING]')
+        )
+        expect(consoleSpy).toHaveBeenCalledWith(
+          expect.stringContaining('TestRule')
+        )
+
+        consoleSpy.mockRestore()
+      })
+
+      it('should log resolved alerts', () => {
+        const consoleSpy = vi.spyOn(console, 'info').mockImplementation(() => {})
+        const handler = createConsoleAlertHandler()
+
+        const notification: AlertNotification = {
+          alert: {
+            rule: 'TestRule',
+            state: AlertState.RESOLVED,
+            severity: AlertSeverity.WARNING,
+            value: 50,
+            threshold: 100,
+            description: 'Test alert',
+            labels: {},
+            annotations: {},
+            firingCount: 1,
+            durationMs: 5000,
+          },
+          timestamp: Date.now(),
+          service: 'test-service',
+          environment: 'test',
+        }
+
+        handler(notification)
+
+        expect(consoleSpy).toHaveBeenCalledWith(
+          expect.stringContaining('[RESOLVED]')
+        )
+
+        consoleSpy.mockRestore()
+      })
+    })
+
+    describe('createWebhookAlertHandler()', () => {
+      it('should POST to webhook URL', async () => {
+        const fetchSpy = vi.spyOn(global, 'fetch').mockResolvedValue(new Response('OK'))
+
+        const handler = createWebhookAlertHandler({
+          url: 'https://webhooks.example.com/alerts',
+          headers: { 'X-API-Key': 'test-key' },
+        })
+
+        const notification: AlertNotification = {
+          alert: {
+            rule: 'TestRule',
+            state: AlertState.FIRING,
+            severity: AlertSeverity.CRITICAL,
+            value: 150,
+            threshold: 100,
+            description: 'Test alert',
+            labels: {},
+            annotations: {},
+            firingCount: 1,
+          },
+          timestamp: Date.now(),
+          service: 'test-service',
+          environment: 'test',
+        }
+
+        await handler(notification)
+
+        expect(fetchSpy).toHaveBeenCalledWith(
+          'https://webhooks.example.com/alerts',
+          expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({
+              'Content-Type': 'application/json',
+              'X-API-Key': 'test-key',
+            }),
+          })
+        )
+
+        fetchSpy.mockRestore()
+      })
+
+      it('should support custom payload transformation', async () => {
+        const fetchSpy = vi.spyOn(global, 'fetch').mockResolvedValue(new Response('OK'))
+
+        const handler = createWebhookAlertHandler({
+          url: 'https://slack.example.com/webhook',
+          transformPayload: (notification) => ({
+            text: `Alert: ${notification.alert.rule}`,
+            channel: '#alerts',
+          }),
+        })
+
+        const notification: AlertNotification = {
+          alert: {
+            rule: 'SlackAlert',
+            state: AlertState.FIRING,
+            severity: AlertSeverity.WARNING,
+            value: 150,
+            threshold: 100,
+            description: 'Test alert',
+            labels: {},
+            annotations: {},
+            firingCount: 1,
+          },
+          timestamp: Date.now(),
+          service: 'test-service',
+          environment: 'test',
+        }
+
+        await handler(notification)
+
+        expect(fetchSpy).toHaveBeenCalledWith(
+          expect.any(String),
+          expect.objectContaining({
+            body: expect.stringContaining('SlackAlert'),
+          })
+        )
+
+        fetchSpy.mockRestore()
+      })
+    })
+
+    describe('createMetricsAlertHandler()', () => {
+      it('should record alert metrics', () => {
+        const collector = createMetricsCollector()
+        const handler = createMetricsAlertHandler(collector)
+
+        const notification: AlertNotification = {
+          alert: {
+            rule: 'MetricsRule',
+            state: AlertState.FIRING,
+            severity: AlertSeverity.CRITICAL,
+            value: 150,
+            threshold: 100,
+            description: 'Test alert',
+            labels: {},
+            annotations: {},
+            firingCount: 1,
+          },
+          timestamp: Date.now(),
+          service: 'test-service',
+          environment: 'test',
+        }
+
+        handler(notification)
+
+        const metrics = collector.getMetrics()
+
+        const alertTotal = metrics.find(m => m.name === 'postgres.alerts.total')
+        expect(alertTotal).toBeDefined()
+        expect(alertTotal?.value).toBe(1)
+        expect(alertTotal?.tags.rule).toBe('MetricsRule')
+        expect(alertTotal?.tags.severity).toBe(AlertSeverity.CRITICAL)
+        expect(alertTotal?.tags.state).toBe(AlertState.FIRING)
+
+        const firingGauge = metrics.find(
+          m => m.name === 'postgres.alerts.firing' && m.tags.rule === 'MetricsRule'
+        )
+        expect(firingGauge?.value).toBe(1)
+      })
+
+      it('should set firing gauge to 0 on resolution', () => {
+        const collector = createMetricsCollector()
+        const handler = createMetricsAlertHandler(collector)
+
+        const notification: AlertNotification = {
+          alert: {
+            rule: 'ResolvedRule',
+            state: AlertState.RESOLVED,
+            severity: AlertSeverity.WARNING,
+            value: 50,
+            threshold: 100,
+            description: 'Resolved alert',
+            labels: {},
+            annotations: {},
+            firingCount: 1,
+          },
+          timestamp: Date.now(),
+          service: 'test-service',
+          environment: 'test',
+        }
+
+        handler(notification)
+
+        const metrics = collector.getMetrics()
+        const firingGauge = metrics.find(
+          m => m.name === 'postgres.alerts.firing' && m.tags.rule === 'ResolvedRule'
+        )
+        expect(firingGauge?.value).toBe(0)
+      })
+    })
+  })
+
+  describe('getAlerts() / getFiringAlerts() / getAlertHistory()', () => {
+    it('should return current alerts', async () => {
+      const rule: AlertRule = {
+        name: 'GetAlertsRule',
+        description: 'Get alerts test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      await alertManager.evaluate()
+
+      const alerts = alertManager.getAlerts()
+      expect(alerts.some(a => a.rule === 'GetAlertsRule')).toBe(true)
+    })
+
+    it('should return only firing alerts', async () => {
+      const firingRule: AlertRule = {
+        name: 'FiringRule',
+        description: 'Firing',
+        metric: 'firing.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      const notFiringRule: AlertRule = {
+        name: 'NotFiringRule',
+        description: 'Not firing',
+        metric: 'notfiring.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(firingRule)
+      alertManager.addRule(notFiringRule)
+
+      metricsCollector.gauge('firing.metric', 150)
+      metricsCollector.gauge('notfiring.metric', 50)
+
+      await alertManager.evaluate()
+
+      const firingAlerts = alertManager.getFiringAlerts()
+      expect(firingAlerts.some(a => a.rule === 'FiringRule')).toBe(true)
+      expect(firingAlerts.some(a => a.rule === 'NotFiringRule')).toBe(false)
+    })
+
+    it('should maintain alert history', async () => {
+      const rule: AlertRule = {
+        name: 'HistoryRule',
+        description: 'History test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+
+      // Fire
+      metricsCollector.gauge('test.metric', 150)
+      await alertManager.evaluate()
+
+      // Resolve
+      metricsCollector.reset()
+      metricsCollector.gauge('test.metric', 50)
+      await alertManager.evaluate()
+
+      const history = alertManager.getAlertHistory()
+      expect(history.length).toBeGreaterThanOrEqual(2)
+
+      // Most recent should be resolved
+      const resolvedAlerts = history.filter(a => a.state === AlertState.RESOLVED)
+      expect(resolvedAlerts.length).toBeGreaterThan(0)
+    })
+
+    it('should limit history size', async () => {
+      const rule: AlertRule = {
+        name: 'LimitRule',
+        description: 'Limit test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      alertManager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+      await alertManager.evaluate()
+
+      const limitedHistory = alertManager.getAlertHistory(1)
+      expect(limitedHistory.length).toBeLessThanOrEqual(1)
+    })
+  })
+
+  describe('start() / stop()', () => {
+    it('should start automatic evaluation', async () => {
+      vi.useFakeTimers()
+
+      const handler = vi.fn()
+      const manager = new AlertManagerImpl({
+        metricsCollector,
+        serviceName: 'test',
+        environment: 'test',
+        evaluationIntervalMs: 100,
+        handlers: [handler],
+      })
+
+      const rule: AlertRule = {
+        name: 'AutoRule',
+        description: 'Auto evaluation test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      manager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      manager.start()
+
+      await vi.advanceTimersByTimeAsync(150)
+
+      expect(handler).toHaveBeenCalled()
+
+      manager.stop()
+      vi.useRealTimers()
+    })
+
+    it('should stop automatic evaluation', async () => {
+      vi.useFakeTimers()
+
+      const handler = vi.fn()
+      const manager = new AlertManagerImpl({
+        metricsCollector,
+        serviceName: 'test',
+        environment: 'test',
+        evaluationIntervalMs: 100,
+        handlers: [handler],
+      })
+
+      const rule: AlertRule = {
+        name: 'StopRule',
+        description: 'Stop test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+      }
+
+      manager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      manager.start()
+      manager.stop()
+
+      handler.mockClear()
+      await vi.advanceTimersByTimeAsync(200)
+
+      expect(handler).not.toHaveBeenCalled()
+
+      vi.useRealTimers()
+    })
+
+    it('should not start multiple timers', () => {
+      const manager = new AlertManagerImpl({
+        metricsCollector,
+        serviceName: 'test',
+        environment: 'test',
+        evaluationIntervalMs: 100,
+      })
+
+      manager.start()
+      manager.start()  // Should not create another timer
+      manager.stop()
+    })
+  })
+
+  describe('Global Labels', () => {
+    it('should add global labels to all alerts', async () => {
+      const manager = new AlertManagerImpl({
+        metricsCollector,
+        serviceName: 'test',
+        environment: 'test',
+        globalLabels: {
+          cluster: 'us-west-2',
+          version: '1.0.0',
+        },
+      })
+
+      const rule: AlertRule = {
+        name: 'GlobalLabelRule',
+        description: 'Global label test',
+        metric: 'test.metric',
+        operator: 'gt',
+        threshold: 100,
+        severity: AlertSeverity.WARNING,
+        labels: { custom: 'value' },
+      }
+
+      manager.addRule(rule)
+      metricsCollector.gauge('test.metric', 150)
+
+      const alerts = await manager.evaluate()
+      const alert = alerts.find(a => a.rule === 'GlobalLabelRule')
+
+      expect(alert?.labels).toMatchObject({
+        cluster: 'us-west-2',
+        version: '1.0.0',
+        custom: 'value',
+      })
+
+      manager.stop()
+    })
+  })
+
+  describe('DEFAULT_ALERT_RULES', () => {
+    it('should define standard alert rules', () => {
+      expect(DEFAULT_ALERT_RULES.length).toBeGreaterThan(0)
+
+      const ruleNames = DEFAULT_ALERT_RULES.map(r => r.name)
+      expect(ruleNames).toContain('HighMemoryUsage')
+      expect(ruleNames).toContain('CriticalMemoryUsage')
+      expect(ruleNames).toContain('HighErrorRate')
+      expect(ruleNames).toContain('SlowQueries')
+    })
+
+    it('should have valid rule configurations', () => {
+      for (const rule of DEFAULT_ALERT_RULES) {
+        expect(rule.name).toBeTruthy()
+        expect(rule.description).toBeTruthy()
+        expect(rule.metric).toBeTruthy()
+        expect(rule.operator).toBeTruthy()
+        expect(typeof rule.threshold).toBe('number')
+        expect(Object.values(AlertSeverity)).toContain(rule.severity)
+      }
+    })
+  })
+})