observability-toolkit 2.0.0 → 2.1.1

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

@@ -0,0 +1,1020 @@
+/**
+ * Tests for langfuse-export.ts
+ *
+ * Covers config validation, auth header creation, OTLP conversion, and batching.
+ */
+import { describe, it, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert';
+import { validateLangfuseUrl, validateLangfuseConfig, createLangfuseAuthHeader, evaluationsToOTLPTraces, exportToLangfuse, } from './langfuse-export.js';
+import { HttpStatus, OTLP_TRACE_ID_LENGTH } from '../core/constants.js';
+import { ONE_MILLION, BYTES, } from '../core/units.js';
+import { COUNT_HUNDRED, COUNT_THREE, COUNT_TWO, COUNT_TEN, COUNT_FIFTY, COUNT_FOUR, TEST_BEARER_TOKEN, } from '../../test-helpers/test-constants.js';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const AUTH_HEADER_PREFIX_LENGTH = 6;
+const TEST_EVAL_SCORE_RATIO = 0.85;
+const ONE_DAY_NANOSECONDS = 86400000000000n;
+const MEMORY_USAGE_HIGH_MB = 700;
+const MEMORY_USAGE_BASELINE_MB = 100;
+const MEMORY_USAGE_WARNING_MB = 450;
+describe('langfuse-export', () => {
+    describe('validateLangfuseUrl', () => {
+        describe('valid URLs', () => {
+            it('accepts valid HTTPS URL', () => {
+                const url = 'https://cloud.langfuse.com';
+                assert.strictEqual(validateLangfuseUrl(url), 'https://cloud.langfuse.com');
+            });
+            it('accepts HTTPS URL with port', () => {
+                const url = 'https://langfuse.example.com:8443';
+                assert.strictEqual(validateLangfuseUrl(url), 'https://langfuse.example.com:8443');
+            });
+            it('preserves path for self-hosted Langfuse on subpath', () => {
+                // M4 FIX: Support Langfuse hosted on subpaths like /langfuse or /api
+                const url = 'https://example.com/langfuse';
+                assert.strictEqual(validateLangfuseUrl(url), 'https://example.com/langfuse');
+            });
+            it('preserves API path prefix', () => {
+                const url = 'https://cloud.langfuse.com/api/v1/traces';
+                assert.strictEqual(validateLangfuseUrl(url), 'https://cloud.langfuse.com/api/v1/traces');
+            });
+            it('strips trailing slash from path', () => {
+                const url = 'https://example.com/langfuse/';
+                assert.strictEqual(validateLangfuseUrl(url), 'https://example.com/langfuse');
+            });
+            it('strips query params from URL', () => {
+                const url = 'https://cloud.langfuse.com?key=value';
+                assert.strictEqual(validateLangfuseUrl(url), 'https://cloud.langfuse.com');
+            });
+            it('strips query params but preserves path', () => {
+                const url = 'https://example.com/langfuse?key=value';
+                assert.strictEqual(validateLangfuseUrl(url), 'https://example.com/langfuse');
+            });
+        });
+        describe('SSRF protection - rejects localhost', () => {
+            it('rejects localhost', () => {
+                assert.strictEqual(validateLangfuseUrl('https://localhost'), '');
+            });
+            it('rejects 127.0.0.1', () => {
+                assert.strictEqual(validateLangfuseUrl('https://127.0.0.1'), '');
+            });
+            it('rejects 127.x.x.x variants', () => {
+                assert.strictEqual(validateLangfuseUrl('https://127.100.200.1'), '');
+            });
+            it('rejects ::1 IPv6 localhost', () => {
+                assert.strictEqual(validateLangfuseUrl('https://[::1]'), '');
+            });
+            it('rejects 0.0.0.0', () => {
+                assert.strictEqual(validateLangfuseUrl('https://0.0.0.0'), '');
+            });
+            it('rejects .localhost TLD', () => {
+                assert.strictEqual(validateLangfuseUrl('https://app.localhost'), '');
+            });
+        });
+        describe('SSRF protection - rejects cloud metadata', () => {
+            it('rejects AWS/GCP/Azure metadata IP', () => {
+                assert.strictEqual(validateLangfuseUrl('https://169.254.169.254'), '');
+            });
+            it('rejects link-local range', () => {
+                assert.strictEqual(validateLangfuseUrl('https://169.254.0.1'), '');
+            });
+        });
+        describe('SSRF protection - rejects private networks', () => {
+            it('rejects 10.x.x.x', () => {
+                assert.strictEqual(validateLangfuseUrl('https://10.0.0.1'), '');
+            });
+            it('rejects 192.168.x.x', () => {
+                assert.strictEqual(validateLangfuseUrl('https://192.168.1.1'), '');
+            });
+            it('rejects 172.16-31.x.x', () => {
+                assert.strictEqual(validateLangfuseUrl('https://172.16.0.1'), '');
+                assert.strictEqual(validateLangfuseUrl('https://172.31.255.255'), '');
+            });
+            it('rejects fc/fd IPv6 ULA', () => {
+                assert.strictEqual(validateLangfuseUrl('https://[fc00::1]'), '');
+                assert.strictEqual(validateLangfuseUrl('https://[fd00::1]'), '');
+            });
+            it('rejects fe80 IPv6 link-local', () => {
+                assert.strictEqual(validateLangfuseUrl('https://[fe80::1]'), '');
+            });
+        });
+        describe('SSRF protection - rejects reserved domains', () => {
+            it('rejects .local TLD', () => {
+                assert.strictEqual(validateLangfuseUrl('https://server.local'), '');
+            });
+            it('rejects .internal TLD', () => {
+                assert.strictEqual(validateLangfuseUrl('https://api.internal'), '');
+            });
+            it('rejects .localdomain TLD', () => {
+                assert.strictEqual(validateLangfuseUrl('https://host.localdomain'), '');
+            });
+            it('rejects .home.arpa TLD', () => {
+                assert.strictEqual(validateLangfuseUrl('https://server.home.arpa'), '');
+            });
+        });
+        describe('SSRF protection - rejects HTTP', () => {
+            it('rejects HTTP protocol', () => {
+                assert.strictEqual(validateLangfuseUrl('http://cloud.langfuse.com'), '');
+            });
+            it('rejects file protocol', () => {
+                assert.strictEqual(validateLangfuseUrl('file:///etc/passwd'), '');
+            });
+        });
+        describe('edge cases', () => {
+            it('returns empty for empty string', () => {
+                assert.strictEqual(validateLangfuseUrl(''), '');
+            });
+            it('returns empty for invalid URL', () => {
+                assert.strictEqual(validateLangfuseUrl('not-a-url'), '');
+            });
+        });
+    });
+    describe('validateLangfuseConfig', () => {
+        const originalEnv = { ...process.env };
+        beforeEach(() => {
+            delete process.env.LANGFUSE_ENDPOINT;
+            delete process.env.LANGFUSE_PUBLIC_KEY;
+            delete process.env.LANGFUSE_SECRET_KEY;
+            delete process.env.LANGFUSE_BATCH_SIZE;
+            delete process.env.LANGFUSE_TIMEOUT_MS;
+        });
+        afterEach(() => {
+            Object.assign(process.env, originalEnv);
+        });
+        it('throws when endpoint not configured', () => {
+            assert.throws(() => validateLangfuseConfig(), /Langfuse endpoint must be a valid URL/);
+        });
+        it('throws when endpoint is invalid', () => {
+            assert.throws(() => validateLangfuseConfig({ endpoint: 'http://localhost' }), /Langfuse endpoint must be HTTPS/);
+        });
+        it('throws when public key not configured', () => {
+            assert.throws(() => validateLangfuseConfig({ endpoint: 'https://cloud.langfuse.com' }), /Langfuse public key is required/);
+        });
+        it('throws when secret key not configured', () => {
+            assert.throws(() => validateLangfuseConfig({
+                endpoint: 'https://cloud.langfuse.com',
+                publicKey: 'pk-test',
+            }), /Langfuse secret key is required/);
+        });
+        it('returns valid config with all required fields', () => {
+            const config = validateLangfuseConfig({
+                endpoint: 'https://cloud.langfuse.com',
+                publicKey: 'pk-test',
+                secretKey: 'sk-test',
+            });
+            assert.strictEqual(config.endpoint, 'https://cloud.langfuse.com');
+            assert.strictEqual(config.publicKey, 'pk-test');
+            assert.strictEqual(config.secretKey, 'sk-test');
+            assert.strictEqual(config.batchSize, COUNT_HUNDRED); // default
+            assert.strictEqual(config.timeoutMs, DEFAULT_TIMEOUT_MS); // default
+        });
+        it('uses custom batch size', () => {
+            const config = validateLangfuseConfig({
+                endpoint: 'https://cloud.langfuse.com',
+                publicKey: 'pk-test',
+                secretKey: 'sk-test',
+                batchSize: 50,
+            });
+            assert.strictEqual(config.batchSize, COUNT_FIFTY);
+        });
+        it('throws when batch size too small', () => {
+            assert.throws(() => validateLangfuseConfig({
+                endpoint: 'https://cloud.langfuse.com',
+                publicKey: 'pk-test',
+                secretKey: 'sk-test',
+                batchSize: 0,
+            }), /Batch size must be at/);
+        });
+        it('throws when batch size too large', () => {
+            assert.throws(() => validateLangfuseConfig({
+                endpoint: 'https://cloud.langfuse.com',
+                publicKey: 'pk-test',
+                secretKey: 'sk-test',
+                batchSize: 1001,
+            }), /Batch size must be at/);
+        });
+        it('throws when timeout too small', () => {
+            assert.throws(() => validateLangfuseConfig({
+                endpoint: 'https://cloud.langfuse.com',
+                publicKey: 'pk-test',
+                secretKey: 'sk-test',
+                timeoutMs: 500,
+            }), /Timeout must be at/);
+        });
+        it('throws when timeout too large', () => {
+            assert.throws(() => validateLangfuseConfig({
+                endpoint: 'https://cloud.langfuse.com',
+                publicKey: 'pk-test',
+                secretKey: 'sk-test',
+                timeoutMs: 200000,
+            }), /Timeout must be at/);
+        });
+    });
+    describe('createLangfuseAuthHeader', () => {
+        it('creates Basic auth header with base64 encoding', () => {
+            const header = createLangfuseAuthHeader('pk-test', 'sk-test');
+            assert.ok(header.startsWith('Basic '));
+            // Decode and verify
+            const encoded = header.slice(AUTH_HEADER_PREFIX_LENGTH);
+            const decoded = Buffer.from(encoded, 'base64').toString('utf-8');
+            assert.strictEqual(decoded, 'pk-test:sk-test');
+        });
+        it('handles special characters in keys', () => {
+            const header = createLangfuseAuthHeader('pk-test+special', 'sk-test=value');
+            const encoded = header.slice(AUTH_HEADER_PREFIX_LENGTH);
+            const decoded = Buffer.from(encoded, 'base64').toString('utf-8');
+            assert.strictEqual(decoded, 'pk-test+special:sk-test=value');
+        });
+    });
+    describe('evaluationsToOTLPTraces', () => {
+        const baseEvaluation = {
+            timestamp: '2024-01-15T10:00:00Z',
+            evaluationName: 'relevance',
+            scoreValue: TEST_EVAL_SCORE_RATIO,
+            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 = evaluationsToOTLPTraces([baseEvaluation]);
+            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');
+            assert.ok(event.attributes);
+            // Check evaluation 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_EVAL_SCORE_RATIO);
+            assert.strictEqual(attrs['gen_ai.evaluation.score.label'], 'good');
+            assert.strictEqual(attrs['gen_ai.evaluation.explanation'], 'The response was relevant');
+        });
+        it('groups multiple evaluations by traceId', () => {
+            const evaluations = [
+                { ...baseEvaluation, traceId: 'trace-1' },
+                { ...baseEvaluation, traceId: 'trace-1', evaluationName: 'quality' },
+                { ...baseEvaluation, traceId: 'trace-2' },
+            ];
+            const result = evaluationsToOTLPTraces(evaluations);
+            // Should have 2 spans (one per traceId)
+            const spans = result.resourceSpans[0].scopeSpans[0].spans;
+            assert.strictEqual(spans.length, COUNT_TWO);
+            // Find the trace-1 span
+            const trace1Span = spans.find(s => s.traceId === 'trace-1');
+            assert.ok(trace1Span);
+            assert.strictEqual(trace1Span.events?.length, COUNT_TWO); // Two evaluations for trace-1
+            // Find the trace-2 span
+            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 = evaluationsToOTLPTraces([evaluation]);
+            const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+            assert.ok(span.traceId);
+            assert.strictEqual(span.traceId.length, OTLP_TRACE_ID_LENGTH); // 32 hex chars
+        });
+        it('handles evaluations with missing optional fields', () => {
+            const minimalEvaluation = {
+                timestamp: '2024-01-15T10:00:00Z',
+                evaluationName: 'test',
+            };
+            const result = evaluationsToOTLPTraces([minimalEvaluation]);
+            const event = result.resourceSpans[0].scopeSpans[0].spans[0].events?.[0];
+            assert.ok(event);
+            assert.strictEqual(event.name, 'gen_ai.evaluation.result');
+            // Should only have the evaluation name attribute
+            const evalNameAttr = event.attributes?.find(a => a.key === 'gen_ai.evaluation.name');
+            assert.ok(evalNameAttr);
+            assert.strictEqual(evalNameAttr.value.stringValue, 'test');
+        });
+        it('includes resource attributes', () => {
+            const result = evaluationsToOTLPTraces([baseEvaluation]);
+            const resourceAttrs = result.resourceSpans[0].resource.attributes;
+            const serviceNameAttr = resourceAttrs.find(a => a.key === 'service.name');
+            assert.ok(serviceNameAttr);
+            assert.strictEqual(serviceNameAttr.value.stringValue, 'observability-toolkit');
+        });
+        it('handles empty evaluations array', () => {
+            const result = evaluationsToOTLPTraces([]);
+            assert.strictEqual(result.resourceSpans[0].scopeSpans[0].spans.length, 0);
+        });
+        // R4 BACKLOG: Extreme timestamp validation (year 3000+)
+        describe('extreme timestamp handling', () => {
+            it('accepts exactly year 2000 timestamp (minimum boundary)', () => {
+                // Year 2000 is exactly EARLIEST_VALID_TIMESTAMP_MS - should be VALID
+                const boundaryEval = {
+                    timestamp: '2000-01-01T00:00:00.000Z',
+                    evaluationName: 'test-boundary-min',
+                };
+                const result = evaluationsToOTLPTraces([boundaryEval]);
+                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+                // Year 2000 = 946684800000 ms from epoch
+                const startNano = BigInt(span.startTimeUnixNano);
+                const expectedMs = new Date('2000-01-01T00:00:00.000Z').getTime();
+                const expectedNs = BigInt(expectedMs) * BigInt(ONE_MILLION);
+                assert.strictEqual(startNano, expectedNs, 'Year 2000 boundary should be precise, not fallback');
+            });
+            it('accepts exactly year 3000 timestamp (maximum boundary)', () => {
+                // Year 3000 is exactly LATEST_VALID_TIMESTAMP_MS - should be VALID
+                const extremeEval = {
+                    timestamp: '3000-01-01T00:00:00Z',
+                    evaluationName: 'test-boundary-max',
+                };
+                const result = evaluationsToOTLPTraces([extremeEval]);
+                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+                const event = span.events?.[0];
+                // Verify the conversion succeeds
+                assert.ok(span.startTimeUnixNano, 'startTimeUnixNano should exist');
+                assert.ok(event?.timeUnixNano, 'event timeUnixNano should exist');
+                // Year 3000 = ~32503680000000 ms from epoch
+                const startNano = BigInt(span.startTimeUnixNano);
+                const expectedMs = new Date('3000-01-01T00:00:00Z').getTime();
+                const expectedNs = BigInt(expectedMs) * BigInt(ONE_MILLION);
+                assert.strictEqual(startNano, expectedNs, 'Year 3000 boundary should be precise, not fallback');
+            });
+            it('uses fallback for year 9999 timestamps (R4 validation)', () => {
+                // Year 9999 exceeds MAX_TIMESTAMP_MS (year 3000) - should use fallback
+                const maxEval = {
+                    timestamp: '9999-12-31T23:59:59Z',
+                    evaluationName: 'test-max-date',
+                };
+                const result = evaluationsToOTLPTraces([maxEval]);
+                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+                // Should use fallback time (Date.now), not the extreme timestamp
+                assert.ok(span.startTimeUnixNano);
+                const startNano = BigInt(span.startTimeUnixNano);
+                // Year 9999 would be ~253402300799000ms; fallback should be much smaller (near now)
+                const year9999Ms = new Date('9999-12-31T23:59:59Z').getTime();
+                const year9999Ns = BigInt(year9999Ms) * BigInt(ONE_MILLION);
+                // Verify we did NOT use the extreme timestamp
+                assert.ok(startNano < year9999Ns, 'Should use fallback time, not year 9999 timestamp');
+                // Fallback should be within 1 day of now
+                const nowNs = BigInt(Date.now()) * BigInt(ONE_MILLION);
+                const diff = startNano > nowNs ? startNano - nowNs : nowNs - startNano;
+                assert.ok(diff < ONE_DAY_NANOSECONDS, 'Fallback should be within 1 day of now');
+            });
+            it('uses fallback for invalid date strings', () => {
+                const invalidEval = {
+                    timestamp: 'not-a-valid-date',
+                    evaluationName: 'test-invalid',
+                };
+                const result = evaluationsToOTLPTraces([invalidEval]);
+                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+                const event = span.events?.[0];
+                // Should fall back to current time, not crash
+                assert.ok(span.startTimeUnixNano);
+                assert.ok(event?.timeUnixNano);
+                // Fallback time should be reasonable (within last day)
+                const nowNs = BigInt(Date.now()) * BigInt(ONE_MILLION);
+                const startNano = BigInt(span.startTimeUnixNano);
+                const diff = startNano - nowNs;
+                assert.ok(diff < ONE_DAY_NANOSECONDS, 'Fallback should be within 1 day of now');
+            });
+            it('uses fallback for timestamps before year 2000 (R4 validation)', () => {
+                // Year 1999 is before MIN_TIMESTAMP_MS (year 2000) - should use fallback
+                const oldEval = {
+                    timestamp: '1999-12-31T23:59:59Z',
+                    evaluationName: 'test-old-date',
+                };
+                const result = evaluationsToOTLPTraces([oldEval]);
+                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+                // Should use fallback time (Date.now), not the old timestamp
+                assert.ok(span.startTimeUnixNano);
+                const startNano = BigInt(span.startTimeUnixNano);
+                // Year 1999 would be ~946598399000ms; fallback should be larger (near now)
+                const year1999Ms = new Date('1999-12-31T23:59:59Z').getTime();
+                const year1999Ns = BigInt(year1999Ms) * BigInt(ONE_MILLION);
+                // Verify we did NOT use the old timestamp
+                assert.ok(startNano > year1999Ns, 'Should use fallback time, not year 1999 timestamp');
+                // Fallback should be within 1 day of now
+                const nowNs = BigInt(Date.now()) * BigInt(ONE_MILLION);
+                const diff = startNano > nowNs ? startNano - nowNs : nowNs - startNano;
+                assert.ok(diff < ONE_DAY_NANOSECONDS, 'Fallback should be within 1 day of now');
+            });
+        });
+        // H3 FIX: BigInt timestamp handling to prevent integer overflow
+        describe('BigInt timestamp handling', () => {
+            it('handles timestamps near MAX_SAFE_INTEGER without precision loss', () => {
+                // Far future timestamp: year 2100 = ~4102444800000 ms
+                const farFutureEval = {
+                    timestamp: '2100-01-01T00:00:00Z',
+                    evaluationName: 'test-future',
+                };
+                const result = evaluationsToOTLPTraces([farFutureEval]);
+                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+                const event = span.events?.[0];
+                // Verify nanosecond timestamps are valid strings
+                assert.ok(span.startTimeUnixNano, 'startTimeUnixNano should exist');
+                assert.ok(span.endTimeUnixNano, 'endTimeUnixNano should exist');
+                assert.ok(event?.timeUnixNano, 'event timeUnixNano should exist');
+                // Parse and verify precision (should be 19+ digits for ns timestamps)
+                const startNano = BigInt(span.startTimeUnixNano);
+                const eventTimeUnixNano = event?.timeUnixNano;
+                assert.ok(eventTimeUnixNano);
+                const eventNano = BigInt(eventTimeUnixNano);
+                // Year 2100 in nanoseconds should be ~4.1e18 - well beyond MAX_SAFE_INTEGER
+                assert.ok(startNano > BigInt(Number.MAX_SAFE_INTEGER), 'Timestamp should exceed MAX_SAFE_INTEGER');
+                // Verify no precision loss by checking string representation
+                // Without BigInt, the result would have trailing zeros or incorrect digits
+                const expectedNs = BigInt(new Date('2100-01-01T00:00:00Z').getTime()) * BigInt(ONE_MILLION);
+                assert.strictEqual(startNano, expectedNs, 'Nanosecond value should match expected');
+                assert.strictEqual(eventNano, expectedNs, 'Event timestamp should match');
+            });
+            it('handles current timestamps correctly', () => {
+                const currentEval = {
+                    timestamp: '2026-02-01T10:00:00Z',
+                    evaluationName: 'test-current',
+                };
+                const result = evaluationsToOTLPTraces([currentEval]);
+                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+                // Current timestamps also exceed MAX_SAFE_INTEGER when converted to ns
+                const startNano = BigInt(span.startTimeUnixNano);
+                const expectedMs = new Date('2026-02-01T10:00:00Z').getTime();
+                const expectedNs = BigInt(expectedMs) * BigInt(ONE_MILLION);
+                assert.strictEqual(startNano, expectedNs, 'Current timestamp should be precise');
+            });
+        });
+    });
+    describe('exportToLangfuse', () => {
+        const mockConfig = {
+            endpoint: 'https://cloud.langfuse.com',
+            publicKey: 'pk-test',
+            secretKey: 'sk-test',
+            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 = [];
+            // Mock global fetch
+            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 exportToLangfuse(testEvaluations, mockConfig);
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.evaluationsExported, COUNT_THREE);
+                assert.strictEqual(result.batches, COUNT_TWO); // 3 evals / batch size 2 = 2 batches
+                assert.strictEqual(result.failed, 0);
+                assert.ok(result.durationMs >= 0);
+                // Verify fetch was called twice (2 batches)
+                assert.strictEqual(fetchCalls.length, COUNT_TWO);
+                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 exportToLangfuse([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 exportToLangfuse([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 exportToLangfuse([], mockConfig);
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(result.evaluationsExported, 0);
+            assert.strictEqual(result.batches, 0);
+            assert.strictEqual(result.failed, 0);
+        });
+        it('includes correct authorization header', 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 exportToLangfuse([testEvaluations[0]], mockConfig);
+                assert.ok(capturedHeaders['Authorization']);
+                assert.ok(capturedHeaders['Authorization'].startsWith('Basic '));
+                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 exportToLangfuse(testEvaluations, {
+                    ...mockConfig,
+                    batchSize: 2,
+                });
+                // First batch of 2 succeeds, second batch of 1 fails
+                assert.strictEqual(result.success, false);
+                assert.strictEqual(result.evaluationsExported, COUNT_TWO);
+                assert.strictEqual(result.failed, 1);
+                assert.strictEqual(result.batches, COUNT_TWO);
+            }
+            finally {
+                globalThis.fetch = originalFetch;
+            }
+        });
+        // C2 FIX: Credential sanitization tests
+        describe('credential sanitization in error responses', () => {
+            it('sanitizes Basic auth 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 credentials: Basic cGstdGVzdDpzay10ZXN0', { status: HttpStatus.UNAUTHORIZED });
+                });
+                try {
+                    await exportToLangfuse([testEvaluations[0]], mockConfig);
+                    assert.ok(!loggedMessage.includes('cGstdGVzdDpzay10ZXN0'), 'Base64 credentials should be redacted');
+                    assert.ok(loggedMessage.includes('[REDACTED]'), 'Should contain [REDACTED]');
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                    console.error = originalConsoleError;
+                }
+            });
+            it('sanitizes pk-xxx:sk-xxx patterns 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('Bad key: pk-mykey123:sk-mysecret456', { status: HttpStatus.UNAUTHORIZED });
+                });
+                try {
+                    await exportToLangfuse([testEvaluations[0]], mockConfig);
+                    assert.ok(!loggedMessage.includes('pk-mykey123'), 'Public key should be redacted');
+                    assert.ok(!loggedMessage.includes('sk-mysecret456'), 'Secret key should be redacted');
+                    assert.ok(loggedMessage.includes('[REDACTED]'), 'Should contain [REDACTED]');
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                    console.error = originalConsoleError;
+                }
+            });
+            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_BEARER_TOKEN}`, { status: HttpStatus.UNAUTHORIZED });
+                });
+                try {
+                    await exportToLangfuse([testEvaluations[0]], mockConfig);
+                    assert.ok(!loggedMessage.includes(TEST_BEARER_TOKEN), 'JWT should be redacted');
+                    assert.ok(loggedMessage.includes('[REDACTED]'), 'Should contain [REDACTED]');
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                    console.error = originalConsoleError;
+                }
+            });
+        });
+        // BACKLOG: Concurrent exports test
+        describe('concurrent exports', () => {
+            it('handles multiple simultaneous exports without interference', async () => {
+                const fetchCalls = [];
+                let batchCounter = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    const batch = ++batchCounter;
+                    fetchCalls.push({ batch, timestamp: Date.now() });
+                    // Simulate network latency
+                    await new Promise(resolve => setTimeout(resolve, COUNT_TEN));
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    // Launch 3 concurrent exports
+                    const [result1, result2, result3] = await Promise.all([
+                        exportToLangfuse([testEvaluations[0]], { ...mockConfig, batchSize: 1 }),
+                        exportToLangfuse([testEvaluations[1]], { ...mockConfig, batchSize: 1 }),
+                        exportToLangfuse([testEvaluations[2]], { ...mockConfig, batchSize: 1 }),
+                    ]);
+                    // All exports should succeed
+                    assert.strictEqual(result1.success, true);
+                    assert.strictEqual(result2.success, true);
+                    assert.strictEqual(result3.success, true);
+                    // Total should be 3 fetches
+                    assert.strictEqual(fetchCalls.length, COUNT_THREE);
+                    // Combined exports should total 3 evaluations
+                    const totalExported = result1.evaluationsExported + result2.evaluationsExported + result3.evaluationsExported;
+                    assert.strictEqual(totalExported, COUNT_THREE);
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('prevents cascade failures in concurrent exports', async () => {
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async (_url, options) => {
+                    // Parse the body to identify which export this is by evaluation name
+                    const body = options?.body;
+                    const isSecondExport = body?.includes('eval2');
+                    // Second export fails with 400 (client error, not retried)
+                    if (isSecondExport) {
+                        return new Response('Bad Request', { status: HttpStatus.BAD_REQUEST });
+                    }
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    const [result1, result2, result3] = await Promise.all([
+                        exportToLangfuse([testEvaluations[0]], { ...mockConfig, batchSize: 1, timeoutMs: 1000 }),
+                        exportToLangfuse([testEvaluations[1]], { ...mockConfig, batchSize: 1, timeoutMs: 1000 }),
+                        exportToLangfuse([testEvaluations[2]], { ...mockConfig, batchSize: 1, timeoutMs: 1000 }),
+                    ]);
+                    // First and third exports should succeed, second should fail
+                    // This verifies failures don't cascade to other concurrent exports
+                    assert.ok(result1.success, 'First export should succeed');
+                    assert.ok(!result2.success, 'Second export should fail (400 client error)');
+                    assert.ok(result3.success, 'Third export should succeed');
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+        });
+        // BACKLOG: Memory threshold behavior test
+        describe('memory protection', () => {
+            it('aborts export when memory exceeds threshold', async () => {
+                // Mock process.memoryUsage to return high heap usage
+                const originalMemoryUsage = process.memoryUsage;
+                let memoryCallCount = 0;
+                process.memoryUsage = (() => {
+                    memoryCallCount++;
+                    // After first batch, simulate high memory (700MB)
+                    const heapUsed = memoryCallCount > 1
+                        ? MEMORY_USAGE_HIGH_MB * BYTES.MB
+                        : MEMORY_USAGE_BASELINE_MB * 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 exportToLangfuse(manyEvaluations, {
+                        ...mockConfig,
+                        batchSize: COUNT_TEN, // 10 batches needed
+                    });
+                    // Should abort partway through
+                    assert.strictEqual(result.success, false);
+                    assert.ok(result.failed > 0, 'Should have some failed evaluations');
+                    assert.ok(result.errors?.some(e => e.includes('Memory limit exceeded')));
+                    // Should not export all 100
+                    assert.ok(result.evaluationsExported < COUNT_HUNDRED, 'Should abort before exporting all');
+                }
+                finally {
+                    process.memoryUsage = originalMemoryUsage;
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('logs warning when memory is high but continues', async () => {
+                const warnings = [];
+                const originalWarn = console.warn;
+                console.warn = (msg) => { warnings.push(msg); };
+                // Mock process.memoryUsage to return moderately high usage (450MB)
+                const originalMemoryUsage = process.memoryUsage;
+                process.memoryUsage = (() => ({
+                    heapUsed: MEMORY_USAGE_WARNING_MB * BYTES.MB, // Above 400MB warning threshold
+                    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 evaluations = Array.from({ length: COUNT_TEN }, (_, i) => ({
+                        timestamp: '2024-01-15T10:00:00Z',
+                        evaluationName: `eval-${i}`,
+                        scoreValue: 0.5,
+                    }));
+                    const result = await exportToLangfuse(evaluations, {
+                        ...mockConfig,
+                        batchSize: COUNT_TEN,
+                    });
+                    // Should succeed despite high memory (below abort threshold)
+                    assert.strictEqual(result.success, true);
+                    assert.strictEqual(result.evaluationsExported, COUNT_TEN);
+                    // Should have logged a memory warning
+                    assert.ok(warnings.some(w => w.includes('High memory usage')), 'Should warn about high memory usage');
+                }
+                finally {
+                    console.warn = originalWarn;
+                    process.memoryUsage = originalMemoryUsage;
+                    globalThis.fetch = originalFetch;
+                }
+            });
+        });
+        // C1 FIX: DNS rebinding protection tests
+        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 {
+                    // With batch size 1 and 3 evaluations, should call fetch 3 times
+                    // Each call should re-validate the URL
+                    const result = await exportToLangfuse(testEvaluations, {
+                        ...mockConfig,
+                        batchSize: 1,
+                    });
+                    assert.strictEqual(result.success, true);
+                    assert.strictEqual(result.batches, COUNT_THREE);
+                    assert.strictEqual(fetchCallCount, COUNT_THREE);
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('fails batch if endpoint becomes invalid mid-export', async () => {
+                // This tests the DNS rebinding protection: if the endpoint
+                // was modified to point to a blocked address between batches,
+                // subsequent batches should fail validation
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    // Use an invalid endpoint that will fail re-validation
+                    const result = await exportToLangfuse(testEvaluations, {
+                        ...mockConfig,
+                        endpoint: 'http://localhost', // HTTP not allowed, will fail validation
+                        batchSize: 1,
+                    });
+                    // All batches should fail due to invalid endpoint
+                    assert.strictEqual(result.success, false);
+                    assert.strictEqual(result.failed, COUNT_THREE);
+                    assert.strictEqual(fetchCallCount, 0); // No fetch calls made
+                    assert.ok(result.errors?.some(e => e.includes('Endpoint validation failed')));
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('continues processing valid batches after endpoint re-validation', async () => {
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    const result = await exportToLangfuse(testEvaluations, {
+                        ...mockConfig,
+                        batchSize: 2,
+                    });
+                    assert.strictEqual(result.success, true);
+                    assert.strictEqual(result.batches, COUNT_TWO); // 3 evals / batch 2 = 2 batches
+                    assert.strictEqual(fetchCallCount, COUNT_TWO);
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+        });
+        // H1 FIX: Retry logic tests
+        describe('retry logic for transient failures', () => {
+            it('retries on 429 rate limit response', async () => {
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    // First 2 calls return 429, third succeeds
+                    if (fetchCallCount <= COUNT_TWO) {
+                        return new Response('Rate limited', { status: HttpStatus.TOO_MANY_REQUESTS });
+                    }
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    const result = await exportToLangfuse([testEvaluations[0]], {
+                        ...mockConfig,
+                        timeoutMs: 100, // Short timeout for faster test
+                    });
+                    // Should succeed after retries
+                    assert.strictEqual(result.success, true);
+                    assert.strictEqual(result.evaluationsExported, 1);
+                    // Retried 2 times + 1 successful = 3 calls
+                    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++;
+                    // First call returns 500, second succeeds
+                    if (fetchCallCount === 1) {
+                        return new Response('Internal Server Error', { status: HttpStatus.INTERNAL_SERVER_ERROR });
+                    }
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    const result = await exportToLangfuse([testEvaluations[0]], {
+                        ...mockConfig,
+                        timeoutMs: 100,
+                    });
+                    assert.strictEqual(result.success, true);
+                    assert.strictEqual(result.evaluationsExported, 1);
+                    assert.strictEqual(fetchCallCount, COUNT_TWO);
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('retries on 503 service unavailable', async () => {
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    if (fetchCallCount === 1) {
+                        return new Response('Service Unavailable', { status: HttpStatus.SERVICE_UNAVAILABLE });
+                    }
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    const result = await exportToLangfuse([testEvaluations[0]], {
+                        ...mockConfig,
+                        timeoutMs: 100,
+                    });
+                    assert.strictEqual(result.success, true);
+                    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 exportToLangfuse([testEvaluations[0]], {
+                        ...mockConfig,
+                        timeoutMs: 100,
+                    });
+                    // Should fail without retry on 4xx (except 429)
+                    assert.strictEqual(result.success, false);
+                    assert.strictEqual(result.failed, 1);
+                    assert.strictEqual(fetchCallCount, 1);
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('gives up after max retries on persistent 5xx', async () => {
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    return new Response('Server Error', { status: HttpStatus.INTERNAL_SERVER_ERROR });
+                });
+                try {
+                    const result = await exportToLangfuse([testEvaluations[0]], {
+                        ...mockConfig,
+                        timeoutMs: 100,
+                    });
+                    // Should fail after 4 attempts (initial + 3 retries)
+                    assert.strictEqual(result.success, false);
+                    assert.strictEqual(result.failed, 1);
+                    assert.strictEqual(fetchCallCount, COUNT_FOUR); // 1 initial + 3 retries
+                    assert.ok(result.errors?.[0].includes('HTTP 500'));
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            // CRITICAL FIX: Test that network errors are retried (not just AbortError)
+            it('retries on network errors (DNS failure, connection reset)', async () => {
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    // First 2 calls throw network error, third succeeds
+                    if (fetchCallCount <= COUNT_TWO) {
+                        const error = new TypeError('fetch failed');
+                        error.cause = new Error('getaddrinfo ENOTFOUND invalid-host.example.com');
+                        throw error;
+                    }
+                    return new Response('{}', { status: HttpStatus.OK });
+                });
+                try {
+                    const result = await exportToLangfuse([testEvaluations[0]], {
+                        ...mockConfig,
+                        timeoutMs: 100,
+                    });
+                    // Should succeed after retrying network errors
+                    assert.strictEqual(result.success, true);
+                    assert.strictEqual(result.evaluationsExported, 1);
+                    // Retried 2 times + 1 successful = 3 calls
+                    assert.strictEqual(fetchCallCount, COUNT_THREE);
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+            it('gives up after max retries on persistent network errors', async () => {
+                let fetchCallCount = 0;
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = mock.fn(async () => {
+                    fetchCallCount++;
+                    const error = new TypeError('fetch failed');
+                    error.cause = new Error('ECONNREFUSED');
+                    throw error;
+                });
+                try {
+                    const result = await exportToLangfuse([testEvaluations[0]], {
+                        ...mockConfig,
+                        timeoutMs: 100,
+                    });
+                    // Should fail after 4 attempts (initial + 3 retries)
+                    assert.strictEqual(result.success, false);
+                    assert.strictEqual(result.failed, 1);
+                    assert.strictEqual(fetchCallCount, COUNT_FOUR); // 1 initial + 3 retries
+                    assert.ok(result.errors?.[0].includes('retries exhausted'));
+                }
+                finally {
+                    globalThis.fetch = originalFetch;
+                }
+            });
+        });
+    });
+});
+//# sourceMappingURL=langfuse-export.test.js.map