observability-toolkit 2.0.0 → 2.1.1

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

@@ -1,890 +0,0 @@
-/**
- * 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