observability-toolkit 1.8.5 → 2.0.0

package/dist/lib/datadog-export.test.js

@@ -0,0 +1,890 @@
+/**
+ * Tests for datadog-export.ts
+ *
+ * Covers config validation, API endpoint mapping, auth headers, metric type
+ * inference, span/eval metric conversion, and batched export functionality.
+ *
+ * Datadog differs from OTLP-based integrations:
+ * - Uses proprietary HTTP API (not OTLP)
+ * - Two-phase export: spans first, then eval metrics
+ * - Fixed endpoints per site (no SSRF validation needed)
+ * - Three metric types: boolean, score, categorical
+ */
+import { describe, it, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert';
+import { validateDatadogApiKey, validateDatadogConfig, createDatadogAuthHeader, getDatadogEndpoints, inferMetricType, sanitizeDatadogString, evaluationsToDatadogSpans, evaluationsToDatadogEvalMetrics, exportToDatadog, } from './datadog-export.js';
+import { DD_ROOT_SPAN_PARENT_ID, DD_SPAN_DURATION_NS, DD_MIN_BATCH_SIZE, DD_MAX_BATCH_SIZE, DD_MIN_TIMEOUT_MS, DD_MAX_TIMEOUT_MS, DD_API_KEY_MIN_LENGTH, DD_API_KEY_MAX_LENGTH, DD_MAX_STRING_LENGTH_DEFAULT, } from './constants.js';
+describe('datadog-export', () => {
+    describe('validateDatadogApiKey', () => {
+        it('accepts valid minimum-length hex API key', () => {
+            assert.doesNotThrow(() => {
+                validateDatadogApiKey('a'.repeat(DD_API_KEY_MIN_LENGTH));
+            });
+        });
+        it('accepts valid maximum-length hex API key', () => {
+            assert.doesNotThrow(() => {
+                validateDatadogApiKey('a'.repeat(DD_API_KEY_MAX_LENGTH));
+            });
+        });
+        it('accepts mixed case hex characters', () => {
+            assert.doesNotThrow(() => {
+                validateDatadogApiKey('AbCdEf0123456789'.repeat(2));
+            });
+        });
+        it('throws for empty API key', () => {
+            assert.throws(() => validateDatadogApiKey(''), /Datadog API key not configured/);
+        });
+        it('throws for too short API key', () => {
+            assert.throws(() => validateDatadogApiKey('a'.repeat(DD_API_KEY_MIN_LENGTH - 1)), /Invalid Datadog API key format/);
+        });
+        it('throws for too long API key', () => {
+            assert.throws(() => validateDatadogApiKey('a'.repeat(DD_API_KEY_MAX_LENGTH + 1)), /Invalid Datadog API key format/);
+        });
+        it('throws for non-hex characters', () => {
+            assert.throws(() => validateDatadogApiKey('g'.repeat(DD_API_KEY_MIN_LENGTH)), /Invalid Datadog API key format/);
+        });
+        it('throws for API key with special characters', () => {
+            assert.throws(() => validateDatadogApiKey('abcd-efgh-1234-5678'.repeat(2)), /Invalid Datadog API key format/);
+        });
+    });
+    describe('sanitizeDatadogString', () => {
+        it('returns empty string for undefined', () => {
+            assert.strictEqual(sanitizeDatadogString(undefined), '');
+        });
+        it('returns empty string for empty input', () => {
+            assert.strictEqual(sanitizeDatadogString(''), '');
+        });
+        it('preserves normal strings', () => {
+            assert.strictEqual(sanitizeDatadogString('hello world'), 'hello world');
+        });
+        it('removes control characters (ASCII 0-31)', () => {
+            assert.strictEqual(sanitizeDatadogString('hello\x00world'), 'helloworld');
+            assert.strictEqual(sanitizeDatadogString('test\x1Fvalue'), 'testvalue');
+            assert.strictEqual(sanitizeDatadogString('\x00\x01\x02clean'), 'clean');
+        });
+        it('removes control characters (ASCII 127-159)', () => {
+            assert.strictEqual(sanitizeDatadogString('hello\x7Fworld'), 'helloworld');
+            assert.strictEqual(sanitizeDatadogString('test\x9Fvalue'), 'testvalue');
+        });
+        it('preserves newlines by removing them (they are control chars)', () => {
+            assert.strictEqual(sanitizeDatadogString('line1\nline2'), 'line1line2');
+            assert.strictEqual(sanitizeDatadogString('line1\r\nline2'), 'line1line2');
+        });
+        it('preserves tabs by removing them (they are control chars)', () => {
+            assert.strictEqual(sanitizeDatadogString('col1\tcol2'), 'col1col2');
+        });
+        it('limits string to maxLength', () => {
+            const longString = 'a'.repeat(100);
+            assert.strictEqual(sanitizeDatadogString(longString, 50).length, 50);
+        });
+        it('uses default maxLength', () => {
+            const longString = 'a'.repeat(DD_MAX_STRING_LENGTH_DEFAULT * 2);
+            assert.strictEqual(sanitizeDatadogString(longString).length, DD_MAX_STRING_LENGTH_DEFAULT);
+        });
+        it('handles mixed content (control chars and length limit)', () => {
+            const input = '\x00' + 'a'.repeat(100) + '\x00';
+            const result = sanitizeDatadogString(input, 50);
+            assert.strictEqual(result.length, 50);
+            assert.ok(!result.includes('\x00'));
+        });
+        it('preserves unicode characters', () => {
+            assert.strictEqual(sanitizeDatadogString('héllo wörld 日本語'), 'héllo wörld 日本語');
+        });
+        it('preserves emojis', () => {
+            assert.strictEqual(sanitizeDatadogString('test 🚀 emoji'), 'test 🚀 emoji');
+        });
+    });
+    describe('getDatadogEndpoints', () => {
+        const sites = [
+            'datadoghq.com',
+            'us3.datadoghq.com',
+            'us5.datadoghq.com',
+            'datadoghq.eu',
+            'ap1.datadoghq.com',
+        ];
+        for (const site of sites) {
+            describe(`site: ${site}`, () => {
+                it('returns spans endpoint', () => {
+                    const endpoints = getDatadogEndpoints(site);
+                    assert.ok(endpoints.spans.includes('/api/intake/llm-obs/v1/trace/spans'));
+                    assert.ok(endpoints.spans.startsWith('https://'));
+                });
+                it('returns evals endpoint', () => {
+                    const endpoints = getDatadogEndpoints(site);
+                    assert.ok(endpoints.evals.includes('/api/intake/llm-obs/v2/eval-metric'));
+                    assert.ok(endpoints.evals.startsWith('https://'));
+                });
+                it('endpoints match site domain', () => {
+                    const endpoints = getDatadogEndpoints(site);
+                    // Extract expected domain from site
+                    const expectedDomain = site === 'datadoghq.com'
+                        ? 'api.datadoghq.com'
+                        : site === 'datadoghq.eu'
+                            ? 'api.datadoghq.eu'
+                            : `api.${site}`;
+                    assert.ok(endpoints.spans.includes(expectedDomain));
+                    assert.ok(endpoints.evals.includes(expectedDomain));
+                });
+            });
+        }
+    });
+    describe('validateDatadogConfig', () => {
+        const validApiKey = 'a'.repeat(32);
+        const validEnv = {
+            DD_API_KEY: validApiKey,
+            DD_SITE: 'datadoghq.com',
+            DD_LLMOBS_ML_APP: 'test-app',
+        };
+        describe('with valid overrides', () => {
+            it('returns config with all overrides', () => {
+                const config = validateDatadogConfig({
+                    apiKey: validApiKey,
+                    site: 'datadoghq.eu',
+                    mlApp: 'my-app',
+                    batchSize: 50,
+                    timeoutMs: 15000,
+                    exportSpans: true,
+                    exportEvals: false,
+                });
+                assert.strictEqual(config.apiKey, validApiKey);
+                assert.strictEqual(config.site, 'datadoghq.eu');
+                assert.strictEqual(config.mlApp, 'my-app');
+                assert.strictEqual(config.batchSize, 50);
+                assert.strictEqual(config.timeoutMs, 15000);
+                assert.strictEqual(config.exportSpans, true);
+                assert.strictEqual(config.exportEvals, false);
+            });
+            it('defaults exportSpans to true', () => {
+                const config = validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: 'test-app',
+                });
+                assert.strictEqual(config.exportSpans, true);
+            });
+            it('defaults exportEvals to true', () => {
+                const config = validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: 'test-app',
+                });
+                assert.strictEqual(config.exportEvals, true);
+            });
+            it('defaults metricType to auto', () => {
+                const config = validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: 'test-app',
+                });
+                assert.strictEqual(config.metricType, 'auto');
+            });
+        });
+        describe('site validation', () => {
+            it('accepts all valid sites', () => {
+                const sites = [
+                    'datadoghq.com',
+                    'us3.datadoghq.com',
+                    'us5.datadoghq.com',
+                    'datadoghq.eu',
+                    'ap1.datadoghq.com',
+                ];
+                for (const site of sites) {
+                    const config = validateDatadogConfig({
+                        apiKey: validApiKey,
+                        site,
+                        mlApp: 'test-app',
+                    });
+                    assert.strictEqual(config.site, site);
+                }
+            });
+            it('throws for invalid site', () => {
+                assert.throws(() => validateDatadogConfig({
+                    apiKey: validApiKey,
+                    site: 'invalid.datadoghq.com',
+                    mlApp: 'test-app',
+                }), /Invalid Datadog site/);
+            });
+        });
+        describe('mlApp validation', () => {
+            it('throws when mlApp is missing', () => {
+                assert.throws(() => validateDatadogConfig({
+                    apiKey: validApiKey,
+                }), /ML app name not configured/);
+            });
+            it('throws when mlApp is empty string', () => {
+                assert.throws(() => validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: '',
+                }), /ML app name not configured/);
+            });
+        });
+        describe('batchSize validation', () => {
+            it('accepts minimum batch size', () => {
+                const config = validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: 'test-app',
+                    batchSize: DD_MIN_BATCH_SIZE,
+                });
+                assert.strictEqual(config.batchSize, DD_MIN_BATCH_SIZE);
+            });
+            it('accepts maximum batch size', () => {
+                const config = validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: 'test-app',
+                    batchSize: DD_MAX_BATCH_SIZE,
+                });
+                assert.strictEqual(config.batchSize, DD_MAX_BATCH_SIZE);
+            });
+            it('throws for batch size below minimum', () => {
+                assert.throws(() => validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: 'test-app',
+                    batchSize: DD_MIN_BATCH_SIZE - 1,
+                }), /batch size must be between/);
+            });
+            it('throws for batch size above maximum', () => {
+                assert.throws(() => validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: 'test-app',
+                    batchSize: DD_MAX_BATCH_SIZE + 1,
+                }), /batch size must be between/);
+            });
+        });
+        describe('timeoutMs validation', () => {
+            it('accepts minimum timeout', () => {
+                const config = validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: 'test-app',
+                    timeoutMs: DD_MIN_TIMEOUT_MS,
+                });
+                assert.strictEqual(config.timeoutMs, DD_MIN_TIMEOUT_MS);
+            });
+            it('accepts maximum timeout', () => {
+                const config = validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: 'test-app',
+                    timeoutMs: DD_MAX_TIMEOUT_MS,
+                });
+                assert.strictEqual(config.timeoutMs, DD_MAX_TIMEOUT_MS);
+            });
+            it('throws for timeout below minimum', () => {
+                assert.throws(() => validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: 'test-app',
+                    timeoutMs: DD_MIN_TIMEOUT_MS - 1,
+                }), /timeout must be between/);
+            });
+            it('throws for timeout above maximum', () => {
+                assert.throws(() => validateDatadogConfig({
+                    apiKey: validApiKey,
+                    mlApp: 'test-app',
+                    timeoutMs: DD_MAX_TIMEOUT_MS + 1,
+                }), /timeout must be between/);
+            });
+        });
+    });
+    describe('createDatadogAuthHeader', () => {
+        it('returns API key as-is', () => {
+            const apiKey = 'test-api-key-value';
+            const header = createDatadogAuthHeader(apiKey);
+            assert.strictEqual(header, apiKey);
+        });
+        it('preserves hex API key', () => {
+            const apiKey = 'abcdef1234567890'.repeat(2);
+            const header = createDatadogAuthHeader(apiKey);
+            assert.strictEqual(header, apiKey);
+        });
+    });
+    describe('inferMetricType', () => {
+        describe('boolean detection', () => {
+            it('returns boolean for score = 0', () => {
+                const evaluation = {
+                    timestamp: new Date().toISOString(),
+                    evaluationName: 'test',
+                    scoreValue: 0,
+                };
+                assert.strictEqual(inferMetricType(evaluation), 'boolean');
+            });
+            it('returns boolean for score = 1', () => {
+                const evaluation = {
+                    timestamp: new Date().toISOString(),
+                    evaluationName: 'test',
+                    scoreValue: 1,
+                };
+                assert.strictEqual(inferMetricType(evaluation), 'boolean');
+            });
+        });
+        describe('score detection', () => {
+            it('returns score for 0.5', () => {
+                const evaluation = {
+                    timestamp: new Date().toISOString(),
+                    evaluationName: 'test',
+                    scoreValue: 0.5,
+                };
+                assert.strictEqual(inferMetricType(evaluation), 'score');
+            });
+            it('returns score for 0.01', () => {
+                const evaluation = {
+                    timestamp: new Date().toISOString(),
+                    evaluationName: 'test',
+                    scoreValue: 0.01,
+                };
+                assert.strictEqual(inferMetricType(evaluation), 'score');
+            });
+            it('returns score for 0.99', () => {
+                const evaluation = {
+                    timestamp: new Date().toISOString(),
+                    evaluationName: 'test',
+                    scoreValue: 0.99,
+                };
+                assert.strictEqual(inferMetricType(evaluation), 'score');
+            });
+        });
+        describe('categorical detection', () => {
+            it('returns categorical for label only', () => {
+                const evaluation = {
+                    timestamp: new Date().toISOString(),
+                    evaluationName: 'test',
+                    scoreLabel: 'good',
+                };
+                assert.strictEqual(inferMetricType(evaluation), 'categorical');
+            });
+            it('returns categorical for label with out-of-range score', () => {
+                const evaluation = {
+                    timestamp: new Date().toISOString(),
+                    evaluationName: 'test',
+                    scoreValue: 5,
+                    scoreLabel: 'five-stars',
+                };
+                assert.strictEqual(inferMetricType(evaluation), 'categorical');
+            });
+        });
+        describe('default fallback', () => {
+            it('returns score for undefined scoreValue', () => {
+                const evaluation = {
+                    timestamp: new Date().toISOString(),
+                    evaluationName: 'test',
+                };
+                assert.strictEqual(inferMetricType(evaluation), 'score');
+            });
+            it('returns score for negative scoreValue', () => {
+                const evaluation = {
+                    timestamp: new Date().toISOString(),
+                    evaluationName: 'test',
+                    scoreValue: -0.5,
+                };
+                assert.strictEqual(inferMetricType(evaluation), 'score');
+            });
+            it('returns score for scoreValue > 1', () => {
+                const evaluation = {
+                    timestamp: new Date().toISOString(),
+                    evaluationName: 'test',
+                    scoreValue: 1.5,
+                };
+                assert.strictEqual(inferMetricType(evaluation), 'score');
+            });
+        });
+    });
+    describe('evaluationsToDatadogSpans', () => {
+        const baseConfig = {
+            apiKey: 'a'.repeat(32),
+            site: 'datadoghq.com',
+            mlApp: 'test-app',
+            batchSize: 100,
+            timeoutMs: 30000,
+            exportSpans: true,
+            exportEvals: true,
+            metricType: 'auto',
+        };
+        it('converts single evaluation to span', () => {
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'relevance',
+                    scoreValue: 0.85,
+                    traceId: 'abc123',
+                }];
+            const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+            assert.strictEqual(spans.length, 1);
+            assert.strictEqual(spans[0].name, 'evaluation.relevance');
+            assert.strictEqual(spans[0].trace_id, 'abc123');
+            assert.ok(spans[0].span_id);
+            assert.strictEqual(spans[0].parent_id, DD_ROOT_SPAN_PARENT_ID);
+            assert.strictEqual(spans[0].duration, DD_SPAN_DURATION_NS);
+            assert.strictEqual(spans[0].meta.ml_app, 'test-app');
+            assert.strictEqual(spans[0].meta['evaluation.name'], 'relevance');
+            assert.strictEqual(spans[0].meta['evaluation.score'], '0.85');
+        });
+        it('generates trace ID when missing', () => {
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                }];
+            const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+            assert.ok(spans[0].trace_id);
+            assert.strictEqual(spans[0].trace_id.length, 32);
+        });
+        it('includes session ID when present', () => {
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                    sessionId: 'session-123',
+                }];
+            const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+            assert.strictEqual(spans[0].meta['session.id'], 'session-123');
+        });
+        it('includes evaluation label', () => {
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'quality',
+                    scoreLabel: 'excellent',
+                }];
+            const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+            assert.strictEqual(spans[0].meta['evaluation.label'], 'excellent');
+        });
+        it('includes explanation as output', () => {
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                    explanation: 'Response was accurate and helpful',
+                }];
+            const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+            assert.deepStrictEqual(spans[0].meta.output, {
+                value: 'Response was accurate and helpful',
+            });
+        });
+        it('includes evaluator as model_name', () => {
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                    evaluator: 'claude-3-opus',
+                }];
+            const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+            assert.strictEqual(spans[0].meta.model_name, 'claude-3-opus');
+        });
+        describe('evaluator type to span kind mapping', () => {
+            it('maps llm evaluator to llm kind', () => {
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'test',
+                        evaluatorType: 'llm',
+                    }];
+                const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+                assert.strictEqual(spans[0].meta.kind, 'llm');
+            });
+            it('maps human evaluator to tool kind', () => {
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'test',
+                        evaluatorType: 'human',
+                    }];
+                const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+                assert.strictEqual(spans[0].meta.kind, 'tool');
+            });
+            it('maps rule evaluator to tool kind', () => {
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'test',
+                        evaluatorType: 'rule',
+                    }];
+                const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+                assert.strictEqual(spans[0].meta.kind, 'tool');
+            });
+            it('maps classifier evaluator to tool kind', () => {
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'test',
+                        evaluatorType: 'classifier',
+                    }];
+                const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+                assert.strictEqual(spans[0].meta.kind, 'tool');
+            });
+            it('defaults to workflow kind for unknown evaluator', () => {
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'test',
+                        // Use type assertion to test behavior with unrecognized evaluator type
+                        evaluatorType: 'unknown',
+                    }];
+                const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+                assert.strictEqual(spans[0].meta.kind, 'workflow');
+            });
+            it('defaults to workflow kind for undefined evaluator', () => {
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'test',
+                    }];
+                const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+                assert.strictEqual(spans[0].meta.kind, 'workflow');
+            });
+        });
+        it('converts multiple evaluations', () => {
+            const evaluations = [
+                { timestamp: '2024-01-15T10:00:00.000Z', evaluationName: 'relevance', scoreValue: 0.9 },
+                { timestamp: '2024-01-15T10:00:01.000Z', evaluationName: 'accuracy', scoreValue: 0.8 },
+                { timestamp: '2024-01-15T10:00:02.000Z', evaluationName: 'safety', scoreValue: 1 },
+            ];
+            const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+            assert.strictEqual(spans.length, 3);
+            assert.strictEqual(spans[0].name, 'evaluation.relevance');
+            assert.strictEqual(spans[1].name, 'evaluation.accuracy');
+            assert.strictEqual(spans[2].name, 'evaluation.safety');
+        });
+        it('handles invalid timestamp gracefully', () => {
+            const evaluations = [{
+                    timestamp: 'invalid-date',
+                    evaluationName: 'test',
+                }];
+            const spans = evaluationsToDatadogSpans(evaluations, baseConfig);
+            // Should use current time when timestamp is invalid
+            assert.ok(spans[0].start_ns > 0);
+        });
+    });
+    describe('evaluationsToDatadogEvalMetrics', () => {
+        const baseConfig = {
+            apiKey: 'a'.repeat(32),
+            site: 'datadoghq.com',
+            mlApp: 'test-app',
+            batchSize: 100,
+            timeoutMs: 30000,
+            exportSpans: true,
+            exportEvals: true,
+            metricType: 'auto',
+        };
+        it('converts evaluation to eval metric', () => {
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'relevance',
+                    scoreValue: 0.85,
+                    traceId: 'abc123',
+                }];
+            const metrics = evaluationsToDatadogEvalMetrics(evaluations, baseConfig);
+            assert.strictEqual(metrics.length, 1);
+            assert.strictEqual(metrics[0].label, 'relevance');
+            assert.strictEqual(metrics[0].ml_app, 'test-app');
+            assert.strictEqual(metrics[0].metric_type, 'score');
+            assert.strictEqual(metrics[0].score_value, 0.85);
+            assert.strictEqual(metrics[0].assessment, 'pass');
+            assert.ok(metrics[0].join_on.span);
+        });
+        describe('boolean metrics', () => {
+            it('converts score=1 to boolean true with pass', () => {
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'is_safe',
+                        scoreValue: 1,
+                    }];
+                const metrics = evaluationsToDatadogEvalMetrics(evaluations, baseConfig);
+                assert.strictEqual(metrics[0].metric_type, 'boolean');
+                assert.strictEqual(metrics[0].boolean_value, true);
+                assert.strictEqual(metrics[0].assessment, 'pass');
+            });
+            it('converts score=0 to boolean false with fail', () => {
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'is_safe',
+                        scoreValue: 0,
+                    }];
+                const metrics = evaluationsToDatadogEvalMetrics(evaluations, baseConfig);
+                assert.strictEqual(metrics[0].metric_type, 'boolean');
+                assert.strictEqual(metrics[0].boolean_value, false);
+                assert.strictEqual(metrics[0].assessment, 'fail');
+            });
+        });
+        describe('score metrics', () => {
+            it('sets pass for score >= 0.5', () => {
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'quality',
+                        scoreValue: 0.75,
+                    }];
+                const metrics = evaluationsToDatadogEvalMetrics(evaluations, baseConfig);
+                assert.strictEqual(metrics[0].metric_type, 'score');
+                assert.strictEqual(metrics[0].score_value, 0.75);
+                assert.strictEqual(metrics[0].assessment, 'pass');
+            });
+            it('sets fail for score < 0.5', () => {
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'quality',
+                        scoreValue: 0.3,
+                    }];
+                const metrics = evaluationsToDatadogEvalMetrics(evaluations, baseConfig);
+                assert.strictEqual(metrics[0].metric_type, 'score');
+                assert.strictEqual(metrics[0].score_value, 0.3);
+                assert.strictEqual(metrics[0].assessment, 'fail');
+            });
+            it('defaults to 0 for undefined score', () => {
+                const configForced = { ...baseConfig, metricType: 'score' };
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'quality',
+                    }];
+                const metrics = evaluationsToDatadogEvalMetrics(evaluations, configForced);
+                assert.strictEqual(metrics[0].score_value, 0);
+            });
+        });
+        describe('categorical metrics', () => {
+            it('uses scoreLabel for categorical value', () => {
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'sentiment',
+                        scoreLabel: 'positive',
+                    }];
+                const metrics = evaluationsToDatadogEvalMetrics(evaluations, baseConfig);
+                assert.strictEqual(metrics[0].metric_type, 'categorical');
+                assert.strictEqual(metrics[0].categorical_value, 'positive');
+            });
+            it('defaults to unknown for missing label', () => {
+                const configForced = { ...baseConfig, metricType: 'categorical' };
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'sentiment',
+                    }];
+                const metrics = evaluationsToDatadogEvalMetrics(evaluations, configForced);
+                assert.strictEqual(metrics[0].categorical_value, 'unknown');
+            });
+        });
+        describe('forced metric type', () => {
+            it('respects forced boolean type', () => {
+                const configForced = { ...baseConfig, metricType: 'boolean' };
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'test',
+                        scoreValue: 0.5, // Would normally be 'score'
+                    }];
+                const metrics = evaluationsToDatadogEvalMetrics(evaluations, configForced);
+                assert.strictEqual(metrics[0].metric_type, 'boolean');
+            });
+            it('respects forced score type', () => {
+                const configForced = { ...baseConfig, metricType: 'score' };
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'test',
+                        scoreValue: 1, // Would normally be 'boolean'
+                    }];
+                const metrics = evaluationsToDatadogEvalMetrics(evaluations, configForced);
+                assert.strictEqual(metrics[0].metric_type, 'score');
+            });
+            it('respects forced categorical type', () => {
+                const configForced = { ...baseConfig, metricType: 'categorical' };
+                const evaluations = [{
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        evaluationName: 'test',
+                        scoreValue: 0.5,
+                    }];
+                const metrics = evaluationsToDatadogEvalMetrics(evaluations, configForced);
+                assert.strictEqual(metrics[0].metric_type, 'categorical');
+            });
+        });
+        it('includes reasoning from explanation', () => {
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                    scoreValue: 0.9,
+                    explanation: 'The response was comprehensive and accurate',
+                }];
+            const metrics = evaluationsToDatadogEvalMetrics(evaluations, baseConfig);
+            assert.strictEqual(metrics[0].reasoning, 'The response was comprehensive and accurate');
+        });
+        it('converts multiple evaluations', () => {
+            const evaluations = [
+                { timestamp: '2024-01-15T10:00:00.000Z', evaluationName: 'relevance', scoreValue: 0.9 },
+                { timestamp: '2024-01-15T10:00:01.000Z', evaluationName: 'is_safe', scoreValue: 1 },
+                { timestamp: '2024-01-15T10:00:02.000Z', evaluationName: 'sentiment', scoreLabel: 'neutral' },
+            ];
+            const metrics = evaluationsToDatadogEvalMetrics(evaluations, baseConfig);
+            assert.strictEqual(metrics.length, 3);
+            assert.strictEqual(metrics[0].metric_type, 'score');
+            assert.strictEqual(metrics[1].metric_type, 'boolean');
+            assert.strictEqual(metrics[2].metric_type, 'categorical');
+        });
+        it('handles invalid timestamp gracefully', () => {
+            const evaluations = [{
+                    timestamp: 'invalid-date',
+                    evaluationName: 'test',
+                    scoreValue: 0.5,
+                }];
+            const metrics = evaluationsToDatadogEvalMetrics(evaluations, baseConfig);
+            // Should use current time when timestamp is invalid
+            assert.ok(metrics[0].timestamp_ms > 0);
+        });
+    });
+    describe('exportToDatadog', () => {
+        const baseConfig = {
+            apiKey: 'a'.repeat(32),
+            site: 'datadoghq.com',
+            mlApp: 'test-app',
+            batchSize: 100,
+            timeoutMs: 30000,
+            exportSpans: true,
+            exportEvals: true,
+            metricType: 'auto',
+        };
+        let originalFetch;
+        beforeEach(() => {
+            originalFetch = globalThis.fetch;
+        });
+        afterEach(() => {
+            globalThis.fetch = originalFetch;
+        });
+        it('returns success for empty evaluations', async () => {
+            const result = await exportToDatadog([], baseConfig);
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(result.evaluationsExported, 0);
+            assert.strictEqual(result.spansExported, 0);
+            assert.strictEqual(result.evalMetricsExported, 0);
+            assert.strictEqual(result.batches, 0);
+        });
+        it('exports spans and evals in two phases', async () => {
+            const fetchCalls = [];
+            globalThis.fetch = mock.fn(async (url, init) => {
+                fetchCalls.push({
+                    url: url.toString(),
+                    body: init?.body,
+                });
+                return new Response(JSON.stringify({ status: 'ok' }), { status: 200 });
+            });
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                    scoreValue: 0.9,
+                }];
+            const result = await exportToDatadog(evaluations, baseConfig);
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(fetchCalls.length, 2);
+            assert.ok(fetchCalls[0].url.includes('/trace/spans'));
+            assert.ok(fetchCalls[1].url.includes('/eval-metric'));
+        });
+        it('only exports spans when exportEvals is false', async () => {
+            const fetchCalls = [];
+            globalThis.fetch = mock.fn(async (url) => {
+                fetchCalls.push(url.toString());
+                return new Response(JSON.stringify({ status: 'ok' }), { status: 200 });
+            });
+            const config = { ...baseConfig, exportEvals: false };
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                    scoreValue: 0.9,
+                }];
+            const result = await exportToDatadog(evaluations, config);
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(fetchCalls.length, 1);
+            assert.ok(fetchCalls[0].includes('/trace/spans'));
+        });
+        it('only exports evals when exportSpans is false', async () => {
+            const fetchCalls = [];
+            globalThis.fetch = mock.fn(async (url) => {
+                fetchCalls.push(url.toString());
+                return new Response(JSON.stringify({ status: 'ok' }), { status: 200 });
+            });
+            const config = { ...baseConfig, exportSpans: false };
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                    scoreValue: 0.9,
+                }];
+            const result = await exportToDatadog(evaluations, config);
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(fetchCalls.length, 1);
+            assert.ok(fetchCalls[0].includes('/eval-metric'));
+        });
+        it('uses DD-API-KEY header', async () => {
+            let capturedHeaders = {};
+            globalThis.fetch = mock.fn(async (_url, init) => {
+                capturedHeaders = Object.fromEntries(Object.entries(init?.headers || {}));
+                return new Response(JSON.stringify({ status: 'ok' }), { status: 200 });
+            });
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                    scoreValue: 0.9,
+                }];
+            await exportToDatadog(evaluations, baseConfig);
+            assert.strictEqual(capturedHeaders['DD-API-KEY'], baseConfig.apiKey);
+        });
+        it('handles HTTP errors gracefully', async () => {
+            globalThis.fetch = mock.fn(async () => {
+                return new Response('Internal Server Error', { status: 500 });
+            });
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                    scoreValue: 0.9,
+                }];
+            const result = await exportToDatadog(evaluations, baseConfig);
+            assert.strictEqual(result.success, false);
+            assert.ok(result.errors);
+            assert.ok(result.errors.some(e => e.includes('500')));
+        });
+        it('handles network errors gracefully', async () => {
+            globalThis.fetch = mock.fn(async () => {
+                throw new Error('Network error');
+            });
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                    scoreValue: 0.9,
+                }];
+            const result = await exportToDatadog(evaluations, baseConfig);
+            assert.strictEqual(result.success, false);
+            assert.ok(result.errors);
+        });
+        it('batches large exports', async () => {
+            let batchCount = 0;
+            globalThis.fetch = mock.fn(async () => {
+                batchCount++;
+                return new Response(JSON.stringify({ status: 'ok' }), { status: 200 });
+            });
+            const config = { ...baseConfig, batchSize: 10 };
+            const evaluations = Array(25).fill(null).map((_, i) => ({
+                timestamp: '2024-01-15T10:00:00.000Z',
+                evaluationName: `test-${i}`,
+                scoreValue: 0.9,
+            }));
+            const result = await exportToDatadog(evaluations, config);
+            // 25 evals / 10 batch = 3 batches * 2 phases (spans + evals) = 6 calls
+            assert.strictEqual(batchCount, 6);
+            assert.strictEqual(result.batches, 3);
+        });
+        it('reports duration in milliseconds', async () => {
+            globalThis.fetch = mock.fn(async () => {
+                return new Response(JSON.stringify({ status: 'ok' }), { status: 200 });
+            });
+            const evaluations = [{
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    evaluationName: 'test',
+                    scoreValue: 0.9,
+                }];
+            const result = await exportToDatadog(evaluations, baseConfig);
+            assert.ok(result.durationMs >= 0);
+            assert.strictEqual(typeof result.durationMs, 'number');
+        });
+        describe('site-specific endpoints', () => {
+            const sites = [
+                'datadoghq.com',
+                'us3.datadoghq.com',
+                'us5.datadoghq.com',
+                'datadoghq.eu',
+                'ap1.datadoghq.com',
+            ];
+            for (const site of sites) {
+                it(`uses correct endpoints for ${site}`, async () => {
+                    const usedUrls = [];
+                    globalThis.fetch = mock.fn(async (url) => {
+                        usedUrls.push(url.toString());
+                        return new Response(JSON.stringify({ status: 'ok' }), { status: 200 });
+                    });
+                    const config = { ...baseConfig, site };
+                    const evaluations = [{
+                            timestamp: '2024-01-15T10:00:00.000Z',
+                            evaluationName: 'test',
+                            scoreValue: 0.9,
+                        }];
+                    await exportToDatadog(evaluations, config);
+                    const expectedEndpoints = getDatadogEndpoints(site);
+                    assert.ok(usedUrls.includes(expectedEndpoints.spans));
+                    assert.ok(usedUrls.includes(expectedEndpoints.evals));
+                });
+            }
+        });
+    });
+});
+//# sourceMappingURL=datadog-export.test.js.map