observability-toolkit 2.0.0 → 2.1.0

package/dist/lib/exports/phoenix-export.test.js

@@ -0,0 +1,816 @@
+/**
+ * Tests for phoenix-export.ts
+ *
+ * Covers config validation, auth header creation, OTLP conversion, and batching.
+ * Phoenix differs from other integrations in:
+ * - Allowing HTTP for localhost (local development)
+ * - Requiring HTTPS for Phoenix Cloud
+ * - Supporting both Bearer and legacy api_key authentication
+ */
+import { describe, it, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert';
+import { validatePhoenixUrl, validatePhoenixConfig, createPhoenixAuthHeaders, evaluationsToPhoenixTraces, exportToPhoenix, } from './phoenix-export.js';
+import { EXPORT_MAX_BATCH_SIZE, HttpStatus, OTLP_TRACE_ID_LENGTH, PHOENIX_BATCH_SIZE, PHOENIX_EXPORT_FORMAT, PHOENIX_TIMEOUT_MS } from '../core/constants.js';
+import { ONE_MILLION, BYTES, } from '../core/units.js';
+import { TEST_SCORE_STRONG } from '../quality/quality-test-constants.js';
+import { COUNT_FIFTY, COUNT_HUNDRED, COUNT_SEVEN, COUNT_THREE, COUNT_TWO, TEST_PHOENIX_SECRET_KEY, } from '../../test-helpers/test-constants.js';
+describe('phoenix-export', () => {
+    describe('validatePhoenixUrl', () => {
+        describe('Phoenix Cloud URLs', () => {
+            it('accepts valid Phoenix Cloud HTTPS URL', () => {
+                const url = 'https://app.phoenix.arize.com/s/my-space';
+                assert.strictEqual(validatePhoenixUrl(url), 'https://app.phoenix.arize.com/s/my-space');
+            });
+            it('rejects Phoenix Cloud HTTP URL', () => {
+                const url = 'http://app.phoenix.arize.com/s/my-space';
+                assert.strictEqual(validatePhoenixUrl(url), '');
+            });
+            it('preserves Phoenix Cloud path', () => {
+                const url = 'https://app.phoenix.arize.com/s/workspace/project';
+                assert.strictEqual(validatePhoenixUrl(url), 'https://app.phoenix.arize.com/s/workspace/project');
+            });
+            it('strips trailing slash from Phoenix Cloud URL', () => {
+                const url = 'https://app.phoenix.arize.com/s/my-space/';
+                assert.strictEqual(validatePhoenixUrl(url), 'https://app.phoenix.arize.com/s/my-space');
+            });
+        });
+        describe('localhost URLs (local development)', () => {
+            it('accepts HTTP localhost', () => {
+                const url = 'http://localhost:6006';
+                assert.strictEqual(validatePhoenixUrl(url), 'http://localhost:6006');
+            });
+            it('accepts HTTPS localhost', () => {
+                const url = 'https://localhost:6006';
+                assert.strictEqual(validatePhoenixUrl(url), 'https://localhost:6006');
+            });
+            it('accepts HTTP 127.0.0.1', () => {
+                const url = 'http://127.0.0.1:6006';
+                assert.strictEqual(validatePhoenixUrl(url), 'http://127.0.0.1:6006');
+            });
+            it('accepts HTTP 127.x.x.x variants', () => {
+                const url = 'http://127.100.200.1:6006';
+                assert.strictEqual(validatePhoenixUrl(url), 'http://127.100.200.1:6006');
+            });
+            it('accepts HTTP [::1] IPv6 localhost', () => {
+                const url = 'http://[::1]:6006';
+                assert.strictEqual(validatePhoenixUrl(url), 'http://[::1]:6006');
+            });
+            it('accepts HTTP 0.0.0.0', () => {
+                const url = 'http://0.0.0.0:6006';
+                assert.strictEqual(validatePhoenixUrl(url), 'http://0.0.0.0:6006');
+            });
+            it('accepts HTTP .localhost TLD', () => {
+                const url = 'http://phoenix.localhost:6006';
+                assert.strictEqual(validatePhoenixUrl(url), 'http://phoenix.localhost:6006');
+            });
+            it('preserves path for localhost', () => {
+                const url = 'http://localhost:6006/api/v1';
+                assert.strictEqual(validatePhoenixUrl(url), 'http://localhost:6006/api/v1');
+            });
+        });
+        describe('self-hosted external URLs (SSRF protection)', () => {
+            it('accepts HTTPS external URL', () => {
+                const url = 'https://phoenix.example.com';
+                assert.strictEqual(validatePhoenixUrl(url), 'https://phoenix.example.com');
+            });
+            it('rejects HTTP external URL', () => {
+                const url = 'http://phoenix.example.com';
+                assert.strictEqual(validatePhoenixUrl(url), '');
+            });
+            it('rejects private network 10.x.x.x', () => {
+                const url = 'https://10.0.0.1:6006';
+                assert.strictEqual(validatePhoenixUrl(url), '');
+            });
+            it('rejects private network 192.168.x.x', () => {
+                const url = 'https://192.168.1.1:6006';
+                assert.strictEqual(validatePhoenixUrl(url), '');
+            });
+            it('rejects private network 172.16-31.x.x', () => {
+                assert.strictEqual(validatePhoenixUrl('https://172.16.0.1:6006'), '');
+                assert.strictEqual(validatePhoenixUrl('https://172.31.255.255:6006'), '');
+            });
+            it('rejects cloud metadata IP', () => {
+                const url = 'https://169.254.169.254';
+                assert.strictEqual(validatePhoenixUrl(url), '');
+            });
+            it('rejects .local TLD', () => {
+                const url = 'https://phoenix.local';
+                assert.strictEqual(validatePhoenixUrl(url), '');
+            });
+            it('rejects .internal TLD', () => {
+                const url = 'https://phoenix.internal';
+                assert.strictEqual(validatePhoenixUrl(url), '');
+            });
+        });
+        describe('edge cases', () => {
+            it('returns empty for empty string', () => {
+                assert.strictEqual(validatePhoenixUrl(''), '');
+            });
+            it('returns empty for invalid URL', () => {
+                assert.strictEqual(validatePhoenixUrl('not-a-url'), '');
+            });
+            it('rejects file protocol', () => {
+                assert.strictEqual(validatePhoenixUrl('file:///etc/passwd'), '');
+            });
+        });
+    });
+    describe('validatePhoenixConfig', () => {
+        const originalEnv = { ...process.env };
+        beforeEach(() => {
+            delete process.env.PHOENIX_COLLECTOR_ENDPOINT;
+            delete process.env.PHOENIX_API_KEY;
+            delete process.env.PHOENIX_PROJECT_NAME;
+            delete process.env.PHOENIX_BATCH_SIZE;
+            delete process.env.PHOENIX_TIMEOUT_MS;
+        });
+        afterEach(() => {
+            Object.assign(process.env, originalEnv);
+        });
+        it('uses default endpoint when not configured', () => {
+            const config = validatePhoenixConfig({});
+            assert.strictEqual(config.endpoint, 'http://localhost:6006');
+        });
+        it('does not require API key for localhost', () => {
+            const config = validatePhoenixConfig({
+                endpoint: 'http://localhost:6006',
+            });
+            assert.strictEqual(config.apiKey, undefined);
+        });
+        it('requires API key for Phoenix Cloud', () => {
+            assert.throws(() => validatePhoenixConfig({
+                endpoint: 'https://app.phoenix.arize.com/s/my-space',
+            }), /Phoenix API key is required for Phoenix Cloud/);
+        });
+        it('accepts Phoenix Cloud with API key', () => {
+            const config = validatePhoenixConfig({
+                endpoint: 'https://app.phoenix.arize.com/s/my-space',
+                apiKey: 'phx_test_api_key_123',
+            });
+            assert.strictEqual(config.endpoint, 'https://app.phoenix.arize.com/s/my-space');
+            assert.strictEqual(config.apiKey, 'phx_test_api_key_123');
+        });
+        it('uses default project name', () => {
+            const config = validatePhoenixConfig({});
+            assert.strictEqual(config.projectName, 'default');
+        });
+        it('uses custom project name', () => {
+            const config = validatePhoenixConfig({
+                projectName: 'my-project',
+            });
+            assert.strictEqual(config.projectName, 'my-project');
+        });
+        it('throws for empty project name', () => {
+            assert.throws(() => validatePhoenixConfig({
+                projectName: '',
+            }), /Phoenix project name is required/);
+        });
+        it('uses default batch size', () => {
+            const config = validatePhoenixConfig({});
+            assert.strictEqual(config.batchSize, PHOENIX_BATCH_SIZE);
+        });
+        it('uses custom batch size', () => {
+            const config = validatePhoenixConfig({
+                batchSize: COUNT_FIFTY,
+            });
+            assert.strictEqual(config.batchSize, COUNT_FIFTY);
+        });
+        it('throws when batch size too small', () => {
+            assert.throws(() => validatePhoenixConfig({ batchSize: 0 }), /Batch size must be at/);
+        });
+        it('throws when batch size too large', () => {
+            assert.throws(() => validatePhoenixConfig({ batchSize: EXPORT_MAX_BATCH_SIZE + 1 }), /Batch size must be at/);
+        });
+        it('uses default timeout', () => {
+            const config = validatePhoenixConfig({});
+            assert.strictEqual(config.timeoutMs, PHOENIX_TIMEOUT_MS);
+        });
+        it('throws when timeout too small', () => {
+            assert.throws(() => validatePhoenixConfig({ timeoutMs: 500 }), /Timeout must be at/);
+        });
+        it('throws when timeout too large', () => {
+            assert.throws(() => validatePhoenixConfig({ timeoutMs: 200000 }), /Timeout must be at/);
+        });
+        it('uses legacyAuth default false', () => {
+            const config = validatePhoenixConfig({});
+            assert.strictEqual(config.legacyAuth, false);
+        });
+        it('accepts legacyAuth true', () => {
+            const config = validatePhoenixConfig({
+                legacyAuth: true,
+            });
+            assert.strictEqual(config.legacyAuth, true);
+        });
+        it('throws for invalid endpoint', () => {
+            assert.throws(() => validatePhoenixConfig({
+                endpoint: 'http://phoenix.internal:6006',
+            }), /endpoint not configured or invalid/);
+        });
+        it('defaults format to json', () => {
+            const config = validatePhoenixConfig({});
+            assert.strictEqual(config.format, 'json');
+        });
+        it('accepts format protobuf', () => {
+            const config = validatePhoenixConfig({ format: 'protobuf' });
+            assert.strictEqual(config.format, 'protobuf');
+        });
+        it('accepts format json', () => {
+            const config = validatePhoenixConfig({ format: 'json' });
+            assert.strictEqual(config.format, 'json');
+        });
+        it('rejects invalid format', () => {
+            assert.throws(() => validatePhoenixConfig({ format: 'xml' }), /Invalid enum value/);
+        });
+    });
+    describe('createPhoenixAuthHeaders', () => {
+        it('returns empty object when no API key', () => {
+            const headers = createPhoenixAuthHeaders(undefined, false);
+            assert.deepStrictEqual(headers, {});
+        });
+        it('returns Bearer header for modern auth', () => {
+            const headers = createPhoenixAuthHeaders('phx_test_key', false);
+            assert.deepStrictEqual(headers, {
+                'Authorization': 'Bearer phx_test_key',
+            });
+        });
+        it('returns api_key header for legacy auth', () => {
+            const headers = createPhoenixAuthHeaders('phx_test_key', true);
+            assert.deepStrictEqual(headers, {
+                'api_key': 'phx_test_key',
+            });
+        });
+        it('handles API keys with special characters', () => {
+            const headers = createPhoenixAuthHeaders('phx_test-key_123', false);
+            assert.strictEqual(headers['Authorization'], 'Bearer phx_test-key_123');
+        });
+    });
+    describe('evaluationsToPhoenixTraces', () => {
+        const baseConfig = {
+            endpoint: 'http://localhost:6006',
+            projectName: 'test-project',
+            batchSize: 100,
+            timeoutMs: 30000,
+        };
+        const baseEvaluation = {
+            timestamp: '2024-01-15T10:00:00Z',
+            evaluationName: 'relevance',
+            scoreValue: 0.85,
+            scoreLabel: 'good',
+            scoreUnit: 'ratio_0_1',
+            explanation: 'The response was relevant',
+            evaluator: 'gpt-4',
+            evaluatorType: 'llm',
+            responseId: 'resp-123',
+            traceId: 'abc123def456',
+            sessionId: 'session-1',
+        };
+        it('converts single evaluation to OTLP trace', () => {
+            const result = evaluationsToPhoenixTraces([baseEvaluation], baseConfig);
+            assert.strictEqual(result.resourceSpans.length, 1);
+            assert.strictEqual(result.resourceSpans[0].scopeSpans.length, 1);
+            assert.strictEqual(result.resourceSpans[0].scopeSpans[0].spans.length, 1);
+            const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+            assert.strictEqual(span.traceId, 'abc123def456');
+            assert.strictEqual(span.name, 'evaluation_export');
+            assert.ok(span.events);
+            assert.strictEqual(span.events.length, 1);
+            const event = span.events[0];
+            assert.strictEqual(event.name, 'gen_ai.evaluation.result');
+        });
+        it('includes GenAI evaluation attributes', () => {
+            const result = evaluationsToPhoenixTraces([baseEvaluation], baseConfig);
+            const event = result.resourceSpans[0].scopeSpans[0].spans[0].events?.[0];
+            assert.ok(event);
+            assert.ok(event.attributes);
+            const attrs = Object.fromEntries(event.attributes.map(a => [a.key, a.value.stringValue ?? a.value.doubleValue]));
+            assert.strictEqual(attrs['gen_ai.evaluation.name'], 'relevance');
+            assert.strictEqual(attrs['gen_ai.evaluation.score.value'], TEST_SCORE_STRONG);
+            assert.strictEqual(attrs['gen_ai.evaluation.score.label'], 'good');
+            assert.strictEqual(attrs['gen_ai.evaluation.explanation'], 'The response was relevant');
+            assert.strictEqual(attrs['gen_ai.evaluation.evaluator'], 'gpt-4');
+            assert.strictEqual(attrs['gen_ai.evaluation.evaluator.type'], 'llm');
+        });
+        it('includes session.id attribute for session tracking', () => {
+            const result = evaluationsToPhoenixTraces([baseEvaluation], baseConfig);
+            const spanAttrs = result.resourceSpans[0].scopeSpans[0].spans[0].attributes;
+            const sessionAttr = spanAttrs?.find(a => a.key === 'session.id');
+            assert.ok(sessionAttr);
+            assert.strictEqual(sessionAttr.value.stringValue, 'session-1');
+        });
+        it('includes phoenix.project.name in resource attributes', () => {
+            const result = evaluationsToPhoenixTraces([baseEvaluation], baseConfig);
+            const resourceAttrs = result.resourceSpans[0].resource.attributes;
+            const projectAttr = resourceAttrs.find(a => a.key === 'phoenix.project.name');
+            assert.ok(projectAttr);
+            assert.strictEqual(projectAttr.value.stringValue, 'test-project');
+        });
+        it('includes export.type attribute', () => {
+            const result = evaluationsToPhoenixTraces([baseEvaluation], baseConfig);
+            const spanAttrs = result.resourceSpans[0].scopeSpans[0].spans[0].attributes;
+            const exportTypeAttr = spanAttrs?.find(a => a.key === 'export.type');
+            assert.ok(exportTypeAttr);
+            assert.strictEqual(exportTypeAttr.value.stringValue, 'phoenix');
+        });
+        it('groups multiple evaluations by traceId', () => {
+            const evaluations = [
+                { ...baseEvaluation, traceId: 'trace-1' },
+                { ...baseEvaluation, traceId: 'trace-1', evaluationName: 'quality' },
+                { ...baseEvaluation, traceId: 'trace-2' },
+            ];
+            const result = evaluationsToPhoenixTraces(evaluations, baseConfig);
+            const spans = result.resourceSpans[0].scopeSpans[0].spans;
+            assert.strictEqual(spans.length, COUNT_TWO);
+            const trace1Span = spans.find(s => s.traceId === 'trace-1');
+            assert.ok(trace1Span);
+            assert.strictEqual(trace1Span.events?.length, COUNT_TWO);
+            const trace2Span = spans.find(s => s.traceId === 'trace-2');
+            assert.ok(trace2Span);
+            assert.strictEqual(trace2Span.events?.length, 1);
+        });
+        it('generates traceId when not provided', () => {
+            const evaluation = { ...baseEvaluation };
+            delete evaluation.traceId;
+            const result = evaluationsToPhoenixTraces([evaluation], baseConfig);
+            const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+            assert.ok(span.traceId);
+            assert.strictEqual(span.traceId.length, OTLP_TRACE_ID_LENGTH);
+        });
+        it('handles evaluations with missing optional fields', () => {
+            const minimalEvaluation = {
+                timestamp: '2024-01-15T10:00:00Z',
+                evaluationName: 'test',
+            };
+            const result = evaluationsToPhoenixTraces([minimalEvaluation], baseConfig);
+            const event = result.resourceSpans[0].scopeSpans[0].spans[0].events?.[0];
+            assert.ok(event);
+            assert.strictEqual(event.name, 'gen_ai.evaluation.result');
+            const evalNameAttr = event.attributes?.find(a => a.key === 'gen_ai.evaluation.name');
+            assert.ok(evalNameAttr);
+            assert.strictEqual(evalNameAttr.value.stringValue, 'test');
+        });
+        it('handles empty evaluations array', () => {
+            const result = evaluationsToPhoenixTraces([], baseConfig);
+            assert.strictEqual(result.resourceSpans[0].scopeSpans[0].spans.length, 0);
+        });
+        describe('timestamp handling', () => {
+            it('accepts valid timestamps within bounds', () => {
+                const evaluation = {
+                    timestamp: '2024-01-15T10:00:00Z',
+                    evaluationName: 'test',
+                };
+                const result = evaluationsToPhoenixTraces([evaluation], baseConfig);
+                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+                const startNano = BigInt(span.startTimeUnixNano);
+                const expectedMs = new Date('2024-01-15T10:00:00Z').getTime();
+                const expectedNs = BigInt(expectedMs) * BigInt(ONE_MILLION);
+                assert.strictEqual(startNano, expectedNs);
+            });
+            it('uses fallback for invalid date strings', () => {
+                const invalidEval = {
+                    timestamp: 'not-a-valid-date',
+                    evaluationName: 'test-invalid',
+                };
+                const result = evaluationsToPhoenixTraces([invalidEval], baseConfig);
+                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+                const event = span.events?.[0];
+                assert.ok(span.startTimeUnixNano);
+                assert.ok(event?.timeUnixNano);
+            });
+            it('uses fallback for extreme timestamps', () => {
+                const extremeEval = {
+                    timestamp: '9999-12-31T23:59:59Z',
+                    evaluationName: 'test-extreme',
+                };
+                const result = evaluationsToPhoenixTraces([extremeEval], baseConfig);
+                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+                const startNano = BigInt(span.startTimeUnixNano);
+                const year9999Ms = new Date('9999-12-31T23:59:59Z').getTime();
+                const year9999Ns = BigInt(year9999Ms) * BigInt(ONE_MILLION);
+                assert.ok(startNano < year9999Ns, 'Should use fallback time');
+            });
+        });
+    });
+    describe('exportToPhoenix', () => {
+        const mockConfig = {
+            endpoint: 'http://localhost:6006',
+            projectName: 'test-project',
+            batchSize: 2,
+            timeoutMs: 5000,
+        };
+        const testEvaluations = [
+            { timestamp: '2024-01-15T10:00:00Z', evaluationName: 'eval1', scoreValue: 0.8 },
+            { timestamp: '2024-01-15T10:00:01Z', evaluationName: 'eval2', scoreValue: 0.9 },
+            { timestamp: '2024-01-15T10:00:02Z', evaluationName: 'eval3', scoreValue: 0.7 },
+        ];
+        it('batches evaluations correctly', async () => {
+            const fetchCalls = [];
+            const originalFetch = globalThis.fetch;
+            globalThis.fetch = mock.fn(async (url, opts) => {
+                fetchCalls.push({ url: url.toString(), body: opts?.body });
+                return new Response('{}', { status: HttpStatus.OK });
+            });
+            try {
+                const result = await exportToPhoenix(testEvaluations, mockConfig);
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.evaluationsExported, testEvaluations.length);
+                assert.strictEqual(result.batches, Math.ceil(testEvaluations.length / mockConfig.batchSize));
+                assert.strictEqual(result.failed, 0);
+                assert.ok(result.durationMs >= 0);
+                assert.strictEqual(fetchCalls.length, Math.ceil(testEvaluations.length / mockConfig.batchSize));
+                assert.ok(fetchCalls[0].url.includes('/v1/traces'));
+            }
+            finally {
+                globalThis.fetch = originalFetch;
+            }
+        });
+        it('handles HTTP errors', async () => {
+            const originalFetch = globalThis.fetch;
+            globalThis.fetch = mock.fn(async () => {
+                return new Response('Unauthorized', { status: HttpStatus.UNAUTHORIZED });
+            });
+            try {
+                const result = await exportToPhoenix([testEvaluations[0]], mockConfig);
+                assert.strictEqual(result.success, false);
+                assert.strictEqual(result.evaluationsExported, 0);
+                assert.strictEqual(result.failed, 1);
+                assert.ok(result.errors);
+                assert.ok(result.errors[0].includes('HTTP 401'));
+            }
+            finally {
+                globalThis.fetch = originalFetch;
+            }
+        });
+        it('handles network errors', async () => {
+            const originalFetch = globalThis.fetch;
+            globalThis.fetch = mock.fn(async () => {
+                throw new Error('Network error');
+            });
+            try {
+                const result = await exportToPhoenix([testEvaluations[0]], mockConfig);
+                assert.strictEqual(result.success, false);
+                assert.strictEqual(result.failed, 1);
+                assert.ok(result.errors);
+                assert.ok(result.errors[0].includes('Network error'));
+            }
+            finally {
+                globalThis.fetch = originalFetch;
+            }
+        });
+        it('handles empty evaluations array', async () => {
+            const result = await exportToPhoenix([], mockConfig);
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(result.evaluationsExported, 0);
+            assert.strictEqual(result.batches, 0);
+            assert.strictEqual(result.failed, 0);
+        });
+        it('includes Bearer auth header when API key provided', async () => {
+            let capturedHeaders = {};
+            const originalFetch = globalThis.fetch;
+            globalThis.fetch = mock.fn(async (_url, opts) => {
+                capturedHeaders = Object.fromEntries(Object.entries(opts?.headers || {}));
+                return new Response('{}', { status: HttpStatus.OK });
+            });
+            try {
+                await exportToPhoenix([testEvaluations[0]], {
+                    ...mockConfig,
+                    apiKey: 'phx_test_key',
+                });
+                assert.ok(capturedHeaders['Authorization']);
+                assert.strictEqual(capturedHeaders['Authorization'], 'Bearer phx_test_key');
+                assert.strictEqual(capturedHeaders['Content-Type'], 'application/json');
+            }
+            finally {
+                globalThis.fetch = originalFetch;
+            }
+        });
+        it('includes api_key header for legacy auth', async () => {
+            let capturedHeaders = {};
+            const originalFetch = globalThis.fetch;
+            globalThis.fetch = mock.fn(async (_url, opts) => {
+                capturedHeaders = Object.fromEntries(Object.entries(opts?.headers || {}));
+                return new Response('{}', { status: HttpStatus.OK });
+            });
+            try {
+                await exportToPhoenix([testEvaluations[0]], {
+                    ...mockConfig,
+                    apiKey: 'phx_test_key',
+                    legacyAuth: true,
+                });
+                assert.ok(capturedHeaders['api_key']);
+                assert.strictEqual(capturedHeaders['api_key'], 'phx_test_key');
+                assert.ok(!capturedHeaders['Authorization']);
+            }
+            finally {
+                globalThis.fetch = originalFetch;
+            }
+        });
+        it('does not include auth headers when no API key', async () => {
+            let capturedHeaders = {};
+            const originalFetch = globalThis.fetch;
+            globalThis.fetch = mock.fn(async (_url, opts) => {
+                capturedHeaders = Object.fromEntries(Object.entries(opts?.headers || {}));
+                return new Response('{}', { status: HttpStatus.OK });
+            });
+            try {
+                await exportToPhoenix([testEvaluations[0]], mockConfig);
+                assert.ok(!capturedHeaders['Authorization']);
+                assert.ok(!capturedHeaders['api_key']);
+                assert.strictEqual(capturedHeaders['Content-Type'], 'application/json');
+            }
+            finally {
+                globalThis.fetch = originalFetch;
+            }
+        });
+        it('handles partial batch failures', async () => {
+            let callCount = 0;
+            const originalFetch = globalThis.fetch;
+            globalThis.fetch = mock.fn(async () => {
+                callCount++;
+                if (callCount === 1) {
+                    return new Response('{}', { status: HttpStatus.OK });
+                }
+                return new Response('Server Error', { status: HttpStatus.INTERNAL_SERVER_ERROR });
+            });
+            try {
+                const result = await exportToPhoenix(testEvaluations, {
+                    ...mockConfig,
+                    batchSize: 2,
+                });
+                assert.strictEqual(result.success, false);
+                assert.strictEqual(result.evaluationsExported, mockConfig.batchSize);
+                assert.strictEqual(result.failed, 1);
+                assert.strictEqual(result.batches, Math.ceil(testEvaluations.length / mockConfig.batchSize));
+            }
+            finally {
+                globalThis.fetch = originalFetch;
+            }
+        });
+        it('generates projectUrl for Phoenix Cloud', async () => {
+            const originalFetch = globalThis.fetch;
+            globalThis.fetch = mock.fn(async () => {
+                return new Response('{}', { status: HttpStatus.OK });
+            });
+            try {
+                const result = await exportToPhoenix([testEvaluations[0]], {
+                    ...mockConfig,
+                    endpoint: 'https://app.phoenix.arize.com/s/my-space',
+                    apiKey: 'phx_test_key',
+                    projectName: 'my-project',
+                });
+                assert.strictEqual(result.success, true);
+                assert.ok(result.projectUrl);
+                assert.ok(result.projectUrl.includes('my-space'));
+                assert.ok(result.projectUrl.includes('my-project'));
+            }
+            finally {
+                globalThis.fetch = originalFetch;
+            }
+        });
+        describe('protobuf format', () => {
+            it('sends application/x-protobuf Content-Type', async () => {
+                let capturedHeaders = {};
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async (_url, opts) => {
+                    capturedHeaders = Object.fromEntries(Object.entries(opts?.headers || {}));
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    await exportToPhoenix([testEvaluations[0]], {
+                        ...mockConfig,
+                        format: PHOENIX_EXPORT_FORMAT.PROTOBUF,
+                    });
+                    assert.strictEqual(capturedHeaders['Content-Type'], 'application/x-protobuf');
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('sends Uint8Array body', async () => {
+                let capturedBody;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async (_url, opts) => {
+                    capturedBody = opts?.body;
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    await exportToPhoenix([testEvaluations[0]], {
+                        ...mockConfig,
+                        format: PHOENIX_EXPORT_FORMAT.PROTOBUF,
+                    });
+                    assert.ok(capturedBody instanceof Uint8Array, 'Body should be Uint8Array');
+                    assert.ok(capturedBody.length > 0, 'Body should not be empty');
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('default format sends application/json', async () => {
+                let capturedHeaders = {};
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async (_url, opts) => {
+                    capturedHeaders = Object.fromEntries(Object.entries(opts?.headers || {}));
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    await exportToPhoenix([testEvaluations[0]], mockConfig);
+                    assert.strictEqual(capturedHeaders['Content-Type'], 'application/json');
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('default format sends string body', async () => {
+                let capturedBody;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async (_url, opts) => {
+                    capturedBody = opts?.body;
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    await exportToPhoenix([testEvaluations[0]], mockConfig);
+                    assert.strictEqual(typeof capturedBody, 'string');
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+        });
+        describe('credential sanitization in error responses', () => {
+            it('sanitizes Bearer tokens in error text', async () => {
+                const originalFetch = globalThis.fetch;
+                const originalConsoleError = console.error;
+                let loggedMessage = '';
+                console.error = (msg) => { loggedMessage = msg; };
+                globalThis.fetch = mock.fn(async () => {
+                    return new Response(`Invalid Bearer ${TEST_PHOENIX_SECRET_KEY}`, { status: HttpStatus.UNAUTHORIZED });
+                });
+                try {
+                    await exportToPhoenix([testEvaluations[0]], {
+                        ...mockConfig,
+                        apiKey: TEST_PHOENIX_SECRET_KEY,
+                    });
+                    assert.ok(!loggedMessage.includes(TEST_PHOENIX_SECRET_KEY), 'API key should be redacted');
+                    assert.ok(loggedMessage.includes('[REDACTED]'), 'Should contain [REDACTED]');
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                    console.error = originalConsoleError;
+                }
+            });
+        });
+        describe('memory protection', () => {
+            it('aborts export when memory exceeds threshold', async () => {
+                const originalMemoryUsage = process.memoryUsage;
+                let memoryCallCount = 0;
+                process.memoryUsage = (() => {
+                    memoryCallCount++;
+                    const heapUsed = memoryCallCount > 1
+                        ? COUNT_SEVEN * COUNT_HUNDRED * BYTES.MB
+                        : COUNT_HUNDRED * BYTES.MB;
+                    return {
+                        heapUsed,
+                        heapTotal: BYTES.KB * BYTES.MB,
+                        external: 0,
+                        arrayBuffers: 0,
+                        rss: 0,
+                    };
+                });
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    const manyEvaluations = Array.from({ length: COUNT_HUNDRED }, (_, i) => ({
+                        timestamp: '2024-01-15T10:00:00Z',
+                        evaluationName: `eval-${i}`,
+                        scoreValue: 0.5,
+                    }));
+                    const result = await exportToPhoenix(manyEvaluations, {
+                        ...mockConfig,
+                        batchSize: 10,
+                    });
+                    assert.strictEqual(result.success, false);
+                    assert.ok(result.failed > 0);
+                    assert.ok(result.errors?.some(e => e.includes('Memory limit exceeded')));
+                    assert.ok(result.evaluationsExported < COUNT_HUNDRED);
+                }
+                finally {
+                    process.memoryUsage = originalMemoryUsage;
+                    globalThis.fetch = originalFetch;
+                }
+            });
+        });
+        describe('DNS rebinding protection', () => {
+            it('re-validates endpoint before each batch', async () => {
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    const result = await exportToPhoenix(testEvaluations, {
+                        ...mockConfig,
+                        batchSize: 1,
+                    });
+                    assert.strictEqual(result.success, true);
+                    assert.strictEqual(result.batches, testEvaluations.length);
+                    assert.strictEqual(fetchCallCount, testEvaluations.length);
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('fails batch if endpoint becomes invalid mid-export', async () => {
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    const result = await exportToPhoenix(testEvaluations, {
+                        ...mockConfig,
+                        endpoint: 'http://phoenix.internal:6006',
+                        batchSize: 1,
+                    });
+                    assert.strictEqual(result.success, false);
+                    assert.strictEqual(result.failed, testEvaluations.length);
+                    assert.strictEqual(fetchCallCount, 0);
+                    assert.ok(result.errors?.some(e => e.includes('Endpoint validation failed')));
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+        });
+        describe('retry logic', () => {
+            it('retries on 429 rate limit response', async () => {
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    if (fetchCallCount <= COUNT_TWO) {
+                        return new Response('Rate limited', { status: HttpStatus.TOO_MANY_REQUESTS });
+                    }
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    const result = await exportToPhoenix([testEvaluations[0]], {
+                        ...mockConfig,
+                        timeoutMs: COUNT_HUNDRED,
+                    });
+                    assert.strictEqual(result.success, true);
+                    assert.strictEqual(result.evaluationsExported, 1);
+                    assert.strictEqual(fetchCallCount, COUNT_THREE);
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('retries on 500 server error', async () => {
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    if (fetchCallCount === 1) {
+                        return new Response('Internal Server Error', { status: HttpStatus.INTERNAL_SERVER_ERROR });
+                    }
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    const result = await exportToPhoenix([testEvaluations[0]], {
+                        ...mockConfig,
+                        timeoutMs: COUNT_HUNDRED,
+                    });
+                    assert.strictEqual(result.success, true);
+                    assert.strictEqual(result.evaluationsExported, 1);
+                    assert.strictEqual(fetchCallCount, COUNT_TWO);
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('does not retry on 400 bad request', async () => {
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    return new Response('Bad Request', { status: HttpStatus.BAD_REQUEST });
+                });
+                try {
+                    const result = await exportToPhoenix([testEvaluations[0]], {
+                        ...mockConfig,
+                        timeoutMs: 100,
+                    });
+                    assert.strictEqual(result.success, false);
+                    assert.strictEqual(result.failed, 1);
+                    assert.strictEqual(fetchCallCount, 1);
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+        });
+    });
+});
+//# sourceMappingURL=phoenix-export.test.js.map