@dotdo/postgres 0.1.0

package/src/observability/metrics-endpoint.test.ts

@@ -0,0 +1,402 @@
+/**
+ * Tests for Metrics Endpoint
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import {
+  createMetricsEndpoint,
+  createMetricsHandler,
+  negotiateFormat,
+  exportMetricsToJson,
+} from './metrics-endpoint'
+import { createMetricsCollector } from './metrics'
+import type { MetricsCollector } from './types'
+
+describe('metrics-endpoint', () => {
+  let collector: MetricsCollector
+
+  beforeEach(() => {
+    collector = createMetricsCollector()
+    // Add some sample metrics
+    collector.increment('postgres.query.count', 100, { operation: 'SELECT' })
+    collector.increment('postgres.query.count', 50, { operation: 'INSERT' })
+    collector.gauge('postgres.do.storage_bytes', 1048576)
+    collector.histogram('postgres.query.duration_ms', 42, { operation: 'SELECT' })
+  })
+
+  describe('negotiateFormat()', () => {
+    it('should return prometheus for text/plain', () => {
+      expect(negotiateFormat('text/plain')).toBe('prometheus')
+    })
+
+    it('should return json for application/json', () => {
+      expect(negotiateFormat('application/json')).toBe('json')
+    })
+
+    it('should return json for text/json', () => {
+      expect(negotiateFormat('text/json')).toBe('json')
+    })
+
+    it('should return default for null Accept header', () => {
+      expect(negotiateFormat(null)).toBe('prometheus')
+      expect(negotiateFormat(null, 'json')).toBe('json')
+    })
+
+    it('should return default for empty Accept header', () => {
+      expect(negotiateFormat('')).toBe('prometheus')
+    })
+
+    it('should return default for wildcard Accept header', () => {
+      expect(negotiateFormat('*/*')).toBe('prometheus')
+      expect(negotiateFormat('*/*', 'json')).toBe('json')
+    })
+
+    it('should respect quality values', () => {
+      // Prefer JSON with higher quality
+      expect(negotiateFormat('text/plain;q=0.5, application/json;q=1.0')).toBe('json')
+      // Prefer Prometheus with higher quality
+      expect(negotiateFormat('application/json;q=0.5, text/plain;q=1.0')).toBe('prometheus')
+    })
+
+    it('should handle complex Accept headers', () => {
+      expect(
+        negotiateFormat('text/html, application/xhtml+xml, application/json;q=0.9, */*;q=0.8')
+      ).toBe('json')
+    })
+
+    it('should return default for unsupported media types', () => {
+      expect(negotiateFormat('text/html')).toBe('prometheus')
+      expect(negotiateFormat('application/xml')).toBe('prometheus')
+    })
+  })
+
+  describe('exportMetricsToJson()', () => {
+    it('should export metrics with timestamp', () => {
+      const metrics = collector.getMetrics()
+      const result = exportMetricsToJson(metrics)
+
+      expect(result.timestamp).toBeDefined()
+      expect(new Date(result.timestamp).getTime()).not.toBeNaN()
+    })
+
+    it('should include all metrics', () => {
+      const metrics = collector.getMetrics()
+      const result = exportMetricsToJson(metrics)
+
+      expect(result.metrics).toHaveLength(4)
+    })
+
+    it('should include aggregates by default', () => {
+      const metrics = collector.getMetrics()
+      const result = exportMetricsToJson(metrics)
+
+      expect(result.aggregates).toBeDefined()
+      expect(result.aggregates!.counters).toBeDefined()
+      expect(result.aggregates!.gauges).toBeDefined()
+      expect(result.aggregates!.histograms).toBeDefined()
+    })
+
+    it('should aggregate counters correctly', () => {
+      const metrics = collector.getMetrics()
+      const result = exportMetricsToJson(metrics)
+
+      const counters = result.aggregates!.counters
+      expect(counters['postgres.query.count{operation="SELECT"}']).toBe(100)
+      expect(counters['postgres.query.count{operation="INSERT"}']).toBe(50)
+    })
+
+    it('should aggregate gauges correctly', () => {
+      const metrics = collector.getMetrics()
+      const result = exportMetricsToJson(metrics)
+
+      const gauges = result.aggregates!.gauges
+      expect(gauges['postgres.do.storage_bytes']).toBe(1048576)
+    })
+
+    it('should aggregate histograms correctly', () => {
+      const metrics = collector.getMetrics()
+      const result = exportMetricsToJson(metrics)
+
+      const histograms = result.aggregates!.histograms
+      expect(
+        histograms['postgres.query.duration_ms{operation="SELECT"}']
+      ).toEqual({ sum: 42, count: 1 })
+    })
+
+    it('should skip aggregates when disabled', () => {
+      const metrics = collector.getMetrics()
+      const result = exportMetricsToJson(metrics, false)
+
+      expect(result.aggregates).toBeUndefined()
+    })
+  })
+
+  describe('createMetricsEndpoint()', () => {
+    it('should return null for non-metrics paths', async () => {
+      const handler = createMetricsEndpoint(collector)
+
+      const request = new Request('https://example.com/api/users')
+      const response = await handler(request)
+
+      expect(response).toBeNull()
+    })
+
+    it('should return metrics for /metrics path', async () => {
+      const handler = createMetricsEndpoint(collector)
+
+      const request = new Request('https://example.com/metrics')
+      const response = await handler(request)
+
+      expect(response).not.toBeNull()
+      expect(response!.status).toBe(200)
+    })
+
+    it('should use custom path when configured', async () => {
+      const handler = createMetricsEndpoint(collector, { path: '/custom/metrics' })
+
+      const request1 = new Request('https://example.com/metrics')
+      expect(await handler(request1)).toBeNull()
+
+      const request2 = new Request('https://example.com/custom/metrics')
+      expect(await handler(request2)).not.toBeNull()
+    })
+
+    it('should return 401 when authentication fails', async () => {
+      const handler = createMetricsEndpoint(collector, {
+        authenticate: () => false,
+      })
+
+      const request = new Request('https://example.com/metrics')
+      const response = await handler(request)
+
+      expect(response!.status).toBe(401)
+    })
+
+    it('should allow requests when authentication passes', async () => {
+      const handler = createMetricsEndpoint(collector, {
+        authenticate: (req) => req.headers.get('Authorization') === 'Bearer token',
+      })
+
+      const request = new Request('https://example.com/metrics', {
+        headers: { Authorization: 'Bearer token' },
+      })
+      const response = await handler(request)
+
+      expect(response!.status).toBe(200)
+    })
+
+    it('should support async authentication', async () => {
+      const handler = createMetricsEndpoint(collector, {
+        authenticate: async () => {
+          await new Promise((resolve) => setTimeout(resolve, 1))
+          return true
+        },
+      })
+
+      const request = new Request('https://example.com/metrics')
+      const response = await handler(request)
+
+      expect(response!.status).toBe(200)
+    })
+
+    it('should return 405 for non-GET methods', async () => {
+      const handler = createMetricsEndpoint(collector)
+
+      const request = new Request('https://example.com/metrics', {
+        method: 'POST',
+      })
+      const response = await handler(request)
+
+      expect(response!.status).toBe(405)
+      expect(response!.headers.get('Allow')).toBe('GET, OPTIONS')
+    })
+
+    describe('Prometheus format', () => {
+      it('should return Prometheus format by default', async () => {
+        const handler = createMetricsEndpoint(collector)
+
+        const request = new Request('https://example.com/metrics')
+        const response = await handler(request)
+
+        expect(response!.headers.get('Content-Type')).toContain('text/plain')
+        const body = await response!.text()
+        expect(body).toContain('# HELP')
+        expect(body).toContain('# TYPE')
+      })
+
+      it('should return Prometheus format for text/plain Accept', async () => {
+        const handler = createMetricsEndpoint(collector)
+
+        const request = new Request('https://example.com/metrics', {
+          headers: { Accept: 'text/plain' },
+        })
+        const response = await handler(request)
+
+        expect(response!.headers.get('Content-Type')).toContain('text/plain')
+        const body = await response!.text()
+        expect(body).toContain('postgres_query_total')
+      })
+
+      it('should include proper Prometheus content type with version', async () => {
+        const handler = createMetricsEndpoint(collector)
+
+        const request = new Request('https://example.com/metrics', {
+          headers: { Accept: 'text/plain' },
+        })
+        const response = await handler(request)
+
+        expect(response!.headers.get('Content-Type')).toBe(
+          'text/plain; version=0.0.4; charset=utf-8'
+        )
+      })
+    })
+
+    describe('JSON format', () => {
+      it('should return JSON format for application/json Accept', async () => {
+        const handler = createMetricsEndpoint(collector)
+
+        const request = new Request('https://example.com/metrics', {
+          headers: { Accept: 'application/json' },
+        })
+        const response = await handler(request)
+
+        expect(response!.headers.get('Content-Type')).toBe(
+          'application/json; charset=utf-8'
+        )
+      })
+
+      it('should return valid JSON', async () => {
+        const handler = createMetricsEndpoint(collector)
+
+        const request = new Request('https://example.com/metrics', {
+          headers: { Accept: 'application/json' },
+        })
+        const response = await handler(request)
+
+        const body = await response!.json()
+        expect(body.timestamp).toBeDefined()
+        expect(body.metrics).toBeInstanceOf(Array)
+        expect(body.aggregates).toBeDefined()
+      })
+
+      it('should include all metric data in JSON response', async () => {
+        const handler = createMetricsEndpoint(collector)
+
+        const request = new Request('https://example.com/metrics', {
+          headers: { Accept: 'application/json' },
+        })
+        const response = await handler(request)
+
+        const body = await response!.json()
+        expect(body.metrics.length).toBe(4)
+
+        const counterMetric = body.metrics.find(
+          (m: { name: string; tags: { operation: string } }) =>
+            m.name === 'postgres.query.count' && m.tags.operation === 'SELECT'
+        )
+        expect(counterMetric).toBeDefined()
+        expect(counterMetric.value).toBe(100)
+        expect(counterMetric.type).toBe('counter')
+      })
+    })
+
+    describe('content negotiation', () => {
+      it('should prefer higher quality formats', async () => {
+        const handler = createMetricsEndpoint(collector)
+
+        // Prefer JSON
+        const request1 = new Request('https://example.com/metrics', {
+          headers: { Accept: 'text/plain;q=0.5, application/json;q=1.0' },
+        })
+        const response1 = await handler(request1)
+        expect(response1!.headers.get('Content-Type')).toContain('application/json')
+
+        // Prefer Prometheus
+        const request2 = new Request('https://example.com/metrics', {
+          headers: { Accept: 'application/json;q=0.5, text/plain;q=1.0' },
+        })
+        const response2 = await handler(request2)
+        expect(response2!.headers.get('Content-Type')).toContain('text/plain')
+      })
+
+      it('should use configurable default format', async () => {
+        const handler = createMetricsEndpoint(collector, { defaultFormat: 'json' })
+
+        const request = new Request('https://example.com/metrics')
+        const response = await handler(request)
+
+        expect(response!.headers.get('Content-Type')).toContain('application/json')
+      })
+    })
+
+    describe('CORS support', () => {
+      it('should not include CORS headers by default', async () => {
+        const handler = createMetricsEndpoint(collector)
+
+        const request = new Request('https://example.com/metrics')
+        const response = await handler(request)
+
+        expect(response!.headers.get('Access-Control-Allow-Origin')).toBeNull()
+      })
+
+      it('should include CORS headers when enabled', async () => {
+        const handler = createMetricsEndpoint(collector, { enableCors: true })
+
+        const request = new Request('https://example.com/metrics')
+        const response = await handler(request)
+
+        expect(response!.headers.get('Access-Control-Allow-Origin')).toBe('*')
+        expect(response!.headers.get('Access-Control-Allow-Methods')).toContain('GET')
+      })
+
+      it('should handle CORS preflight requests', async () => {
+        const handler = createMetricsEndpoint(collector, { enableCors: true })
+
+        const request = new Request('https://example.com/metrics', {
+          method: 'OPTIONS',
+        })
+        const response = await handler(request)
+
+        expect(response!.status).toBe(204)
+        expect(response!.headers.get('Access-Control-Allow-Origin')).toBe('*')
+        expect(response!.headers.get('Access-Control-Allow-Methods')).toContain('GET')
+        expect(response!.headers.get('Access-Control-Max-Age')).toBe('86400')
+      })
+
+      it('should use configured CORS origins', async () => {
+        const handler = createMetricsEndpoint(collector, {
+          enableCors: true,
+          corsOrigins: ['https://allowed.com', 'https://also-allowed.com'],
+        })
+
+        const request = new Request('https://example.com/metrics', {
+          headers: { Origin: 'https://allowed.com' },
+        })
+        const response = await handler(request)
+
+        expect(response!.headers.get('Access-Control-Allow-Origin')).toBe(
+          'https://allowed.com'
+        )
+      })
+    })
+
+    describe('cache control', () => {
+      it('should include no-cache headers', async () => {
+        const handler = createMetricsEndpoint(collector)
+
+        const request = new Request('https://example.com/metrics')
+        const response = await handler(request)
+
+        expect(response!.headers.get('Cache-Control')).toBe(
+          'no-cache, no-store, must-revalidate'
+        )
+      })
+    })
+  })
+
+  describe('createMetricsHandler alias', () => {
+    it('should be an alias for createMetricsEndpoint', () => {
+      expect(createMetricsHandler).toBe(createMetricsEndpoint)
+    })
+  })
+})