observability-toolkit 2.0.0 → 2.1.0

package/dist/lib/exports/export-utils.js

@@ -0,0 +1,303 @@
+/**
+ * Shared utilities for evaluation export integrations
+ *
+ * Common functionality used by Langfuse, Confident AI, and other export providers.
+ * Extracted to prevent code duplication and ensure consistent behavior.
+ */
+import { webcrypto } from 'crypto';
+import { HttpStatus, BACKOFF_BASE_MS, DEFAULT_MAX_RETRIES, MAX_ERROR_ENTRIES, MAX_ERROR_BODY_SIZE, HEX_DIGITS_PER_BYTE, OTLP_SPAN_ID_LENGTH, } from '../core/constants.js';
+import { BYTES, } from '../core/units.js';
+import { createLogger } from '../core/logger.js';
+const securityLog = createLogger('security');
+// Max backoff for HTTP export retries (Langfuse, Confident AI, etc.).
+// Intentionally lower than LLM judge MAX_BACKOFF_MS (60s) — export pipelines
+// need faster failure feedback, not long waits for rate-limited LLM APIs.
+export const BACKOFF_MAX_MS = 10000;
+export const MEMORY_WARNING_LOG_INTERVAL = 5;
+/** Default timeout for individual HTTP requests in exports */
+export const DEFAULT_FETCH_TIMEOUT_MS = 5000;
+const EXPONENTIAL_BACKOFF_BASE = 2;
+/** Memory protection default values */
+const DEFAULT_MEMORY_WARN_MB = 400;
+const DEFAULT_MEMORY_ABORT_MB = 600;
+/**
+ * Memory warning threshold in MB.
+ * Configurable via EXPORT_MEMORY_WARN_MB environment variable.
+ * Default: 400MB
+ */
+export const MEMORY_WARNING_THRESHOLD_MB = (() => {
+    const envValue = process.env.EXPORT_MEMORY_WARN_MB;
+    if (!envValue)
+        return DEFAULT_MEMORY_WARN_MB;
+    const parsed = parseInt(envValue, 10);
+    return isNaN(parsed) || parsed < 1 ? DEFAULT_MEMORY_WARN_MB : parsed;
+})();
+/**
+ * Memory abort threshold in MB.
+ * Configurable via EXPORT_MEMORY_ABORT_MB environment variable.
+ * Default: 600MB
+ */
+export const MEMORY_ABORT_THRESHOLD_MB = (() => {
+    const envValue = process.env.EXPORT_MEMORY_ABORT_MB;
+    if (!envValue)
+        return DEFAULT_MEMORY_ABORT_MB;
+    const parsed = parseInt(envValue, 10);
+    return isNaN(parsed) || parsed < 1 ? DEFAULT_MEMORY_ABORT_MB : parsed;
+})();
+export const PROGRESS_LOG_INTERVAL = 10;
+/**
+ * Timestamp validation bounds (year 2000-3000).
+ * - Year 2000 minimum: Pre-2000 data is likely clock skew or test artifacts
+ * - Year 3000 maximum: Far-future dates may cause OTLP ingestion failures
+ * - This range allows reasonable forward-dating for testing/scheduling
+ */
+export const EARLIEST_VALID_TIMESTAMP_MS = 946684800000; // 2000-01-01T00:00:00Z
+export const LATEST_VALID_TIMESTAMP_MS = 32503680000000; // 3000-01-01T00:00:00Z
+/**
+ * Check memory usage and return status.
+ * Used to prevent OOM on large exports.
+ */
+export function checkMemoryUsage() {
+    const heapUsed = process.memoryUsage().heapUsed;
+    const heapUsedMB = Math.round(heapUsed / BYTES.MB);
+    return {
+        heapUsedMB,
+        shouldWarn: heapUsedMB > MEMORY_WARNING_THRESHOLD_MB,
+        shouldAbort: heapUsedMB > MEMORY_ABORT_THRESHOLD_MB,
+    };
+}
+/**
+ * Fetch with exponential backoff retry for transient failures.
+ * Retries on network errors, timeouts, 429 (rate limit), and 5xx errors.
+ *
+ * @param url - Target URL for the request
+ * @param options - Fetch options (method, headers, body, etc.)
+ * @param maxRetries - Maximum number of retry attempts (default: 3)
+ * @param timeoutMs - Request timeout in milliseconds (default: DEFAULT_FETCH_TIMEOUT_MS)
+ * @returns Promise resolving to the fetch Response
+ * @throws Error if all retries are exhausted
+ */
+export async function fetchWithRetry(url, options, maxRetries = DEFAULT_MAX_RETRIES, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(url, {
+                ...options,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            // P1-H2 fix: Don't retry 4xx client errors (except 429 rate limit)
+            // A 401 Unauthorized or 400 Bad Request won't succeed on retry
+            // Note: Caller is responsible for consuming the response body to prevent connection pool leaks
+            if (response.status >= HttpStatus.BAD_REQUEST && response.status < HttpStatus.INTERNAL_SERVER_ERROR) {
+                if (response.status !== HttpStatus.TOO_MANY_REQUESTS) {
+                    return response;
+                }
+            }
+            // Retry on rate limit (429) or server errors (5xx)
+            if (response.status === HttpStatus.TOO_MANY_REQUESTS || response.status >= HttpStatus.INTERNAL_SERVER_ERROR) {
+                if (attempt < maxRetries) {
+                    const backoffMs = Math.min(BACKOFF_BASE_MS * Math.pow(EXPONENTIAL_BACKOFF_BASE, attempt), BACKOFF_MAX_MS);
+                    await new Promise(resolve => setTimeout(resolve, backoffMs));
+                    continue;
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            lastError = error instanceof Error ? error : new Error(String(error));
+            // Retry ALL errors (network, DNS, timeouts) not just AbortError
+            if (attempt < maxRetries) {
+                const backoffMs = Math.min(BACKOFF_BASE_MS * Math.pow(EXPONENTIAL_BACKOFF_BASE, attempt), BACKOFF_MAX_MS);
+                await new Promise(resolve => setTimeout(resolve, backoffMs));
+                continue;
+            }
+            // All retries exhausted - throw the last error
+            throw lastError;
+        }
+    }
+    // This line is only reachable if loop exits without return/throw (shouldn't happen)
+    throw lastError || new Error('Max retries exceeded');
+}
+/**
+ * Sanitize error text to prevent credential leakage in logs.
+ * Removes potential API keys, Basic auth tokens, and other sensitive data.
+ *
+ * @param text - Error text to sanitize
+ * @returns Sanitized text with credentials redacted
+ */
+export function sanitizeErrorText(text) {
+    return text
+        // Remove Basic auth headers
+        .replace(/Basic\s+[A-Za-z0-9+/=]+/gi, '[REDACTED]')
+        // Remove pk-xxx:sk-xxx patterns (Langfuse)
+        .replace(/pk-[^:\s]+:[^:\s]+/gi, '[REDACTED]')
+        // Remove bearer tokens
+        .replace(/Bearer\s+[A-Za-z0-9._-]+/gi, '[REDACTED]')
+        // Remove Langfuse API key patterns
+        .replace(/sk-[A-Za-z0-9]{20,}/gi, '[REDACTED]')
+        .replace(/pk-[A-Za-z0-9]{20,}/gi, '[REDACTED]')
+        // Remove Confident AI API key patterns (confident_us...)
+        .replace(/confident_[a-z]{2}[A-Za-z0-9_-]{20,}/gi, '[REDACTED]')
+        // Remove x-confident-api-key header values
+        .replace(/x-confident-api-key:\s*[^\s,]+/gi, 'x-confident-api-key: [REDACTED]')
+        // Remove DD-API-KEY header values (Datadog)
+        .replace(/DD-API-KEY:\s*[^\s,]+/gi, 'DD-API-KEY: [REDACTED]')
+        // Remove generic API key patterns
+        .replace(/api[_-]?key[=:]\s*[^\s&"']+/gi, 'api_key=[REDACTED]');
+}
+/**
+ * Validate and sanitize a URL to prevent SSRF attacks.
+ * By default, only allows HTTPS URLs to external hosts.
+ *
+ * @param url - URL to validate
+ * @param options - Validation options
+ * @returns Validated URL origin (with path preserved) or empty string if invalid
+ */
+export function validateExternalUrl(url, options = {}) {
+    const { allowHttp = false, allowLocalhost = false, provider = 'External', } = options;
+    if (!url)
+        return '';
+    try {
+        const parsed = new URL(url);
+        // Check protocol
+        if (parsed.protocol === 'http:' && !allowHttp) {
+            securityLog.error(`Invalid ${provider} URL protocol - only HTTPS allowed`, { provider });
+            return '';
+        }
+        if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+            securityLog.error(`Invalid ${provider} URL protocol - only HTTP(S) allowed`, { provider });
+            return '';
+        }
+        const hostname = parsed.hostname.toLowerCase();
+        const normalizedHost = hostname.replace(/^\[|\]$/g, '').split('%')[0];
+        // Block localhost variants (unless explicitly allowed)
+        if (!allowLocalhost) {
+            if (normalizedHost === 'localhost' ||
+                /^127\./.test(normalizedHost) ||
+                normalizedHost === '0.0.0.0' ||
+                normalizedHost === '::1' ||
+                normalizedHost === '0:0:0:0:0:0:0:1' ||
+                /^::ffff:127\./.test(normalizedHost) ||
+                normalizedHost.endsWith('.localhost')) {
+                securityLog.error(`Localhost addresses not allowed for ${provider} URL`, { provider });
+                return '';
+            }
+        }
+        // Block cloud metadata endpoints (169.254.0.0/16) - always blocked
+        if (/^169\.254\./.test(normalizedHost) ||
+            /^::ffff:169\.254\./.test(normalizedHost)) {
+            securityLog.error(`Cloud metadata addresses not allowed for ${provider} URL`, { provider });
+            return '';
+        }
+        // Block private network ranges - always blocked
+        if (normalizedHost.startsWith('192.168.') ||
+            normalizedHost.startsWith('10.') ||
+            /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(normalizedHost) ||
+            normalizedHost.startsWith('fc') ||
+            normalizedHost.startsWith('fd') ||
+            normalizedHost.startsWith('fe80') ||
+            normalizedHost.startsWith('::ffff:192.168.') ||
+            normalizedHost.startsWith('::ffff:10.') ||
+            /^::ffff:172\.(1[6-9]|2[0-9]|3[0-1])\./.test(normalizedHost)) {
+            securityLog.error(`Private network addresses not allowed for ${provider} URL`, { provider });
+            return '';
+        }
+        // Block reserved domain suffixes
+        if (normalizedHost.endsWith('.local') ||
+            normalizedHost.endsWith('.internal') ||
+            normalizedHost.endsWith('.localdomain') ||
+            normalizedHost.endsWith('.home.arpa')) {
+            securityLog.error(`Reserved domain names not allowed for ${provider} URL`, { provider });
+            return '';
+        }
+        // Preserve API path prefixes for self-hosted instances on subpaths
+        const path = parsed.pathname;
+        if (path && path !== '/') {
+            // Strip trailing slash for consistency
+            const normalizedPath = path.endsWith('/') ? path.slice(0, -1) : path;
+            return parsed.origin + normalizedPath;
+        }
+        return parsed.origin;
+    }
+    catch {
+        securityLog.error(`Invalid ${provider} URL format`, { provider });
+        return '';
+    }
+}
+/**
+ * Check if a timestamp is within valid bounds (year 2000-3000)
+ *
+ * @param timestampMs - Timestamp in milliseconds
+ * @returns true if timestamp is valid
+ */
+export function isValidTimestamp(timestampMs) {
+    return !isNaN(timestampMs) &&
+        timestampMs >= EARLIEST_VALID_TIMESTAMP_MS &&
+        timestampMs <= LATEST_VALID_TIMESTAMP_MS;
+}
+/**
+ * Generate a random hex string for trace/span IDs using crypto
+ *
+ * @param length - Length of hex string (must be even)
+ * @returns Random hex string of specified length
+ */
+export function generateHexId(length) {
+    const bytes = new Uint8Array(length / HEX_DIGITS_PER_BYTE);
+    webcrypto.getRandomValues(bytes);
+    return Array.from(bytes, b => b.toString(OTLP_SPAN_ID_LENGTH).padStart(HEX_DIGITS_PER_BYTE, '0')).join('');
+}
+/**
+ * Check if a hostname is localhost or a local network address.
+ * Used by Phoenix and other providers that allow localhost for local development.
+ *
+ * @param hostname - Hostname to check
+ * @returns true if the hostname is a localhost variant
+ */
+export function isLocalhostAddress(hostname) {
+    const normalizedHost = hostname.toLowerCase().replace(/^\[|\]$/g, '').split('%')[0];
+    return (normalizedHost === 'localhost' ||
+        /^127\./.test(normalizedHost) ||
+        normalizedHost === '0.0.0.0' ||
+        normalizedHost === '::1' ||
+        normalizedHost === '0:0:0:0:0:0:0:1' ||
+        /^::ffff:127\./.test(normalizedHost) ||
+        normalizedHost.endsWith('.localhost'));
+}
+/**
+ * Push an error message to a capped error array to prevent unbounded growth.
+ * When the array reaches MAX_ERROR_ENTRIES, adds a truncation notice.
+ *
+ * P0-C2 fix: Prevents OOM on large-scale export failures (e.g., 10K evals with 100% failure).
+ *
+ * @param errors - The error array to push to
+ * @param errorMessage - The error message to add
+ */
+export function pushCappedError(errors, errorMessage) {
+    if (errors.length < MAX_ERROR_ENTRIES) {
+        errors.push(errorMessage);
+    }
+    else if (errors.length === MAX_ERROR_ENTRIES) {
+        errors.push(`... and more errors (truncated at ${MAX_ERROR_ENTRIES})`);
+    }
+    // If already at MAX_ERROR_ENTRIES + 1, silently drop new errors
+}
+/**
+ * Truncate HTTP response body to prevent OOM from malicious endpoints.
+ *
+ * P0-H3 fix: A malicious endpoint returning 1GB error payload could cause OOM.
+ * This limits response body reads to MAX_ERROR_BODY_SIZE (10KB).
+ *
+ * @param text - The response body text
+ * @returns Truncated text with indicator if truncated
+ */
+export function truncateErrorBody(text) {
+    if (text.length <= MAX_ERROR_BODY_SIZE) {
+        return text;
+    }
+    return text.slice(0, MAX_ERROR_BODY_SIZE) + '... [truncated]';
+}
+//# sourceMappingURL=export-utils.js.map

package/dist/lib/exports/export-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-utils.js","sourceRoot":"","sources":["../../../src/lib/exports/export-utils.ts"],"names":[],"mappings":"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"}

package/dist/lib/exports/export-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-utils.test.d.ts","sourceRoot":"","sources":["../../../src/lib/exports/export-utils.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

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

@@ -0,0 +1,344 @@
+/**
+ * Tests for export-utils module
+ */
+import { describe, it, beforeEach, afterEach } from 'vitest';
+import assert from 'node:assert';
+import { DD_SPAN_ID_LENGTH, DD_TRACE_ID_LENGTH, OTLP_SPAN_ID_LENGTH, OTLP_TRACE_ID_LENGTH, } from '../core/constants.js';
+import { COUNT_FIFTY, COUNT_FIVE_THOUSAND, COUNT_FOUR, COUNT_HUNDRED, COUNT_SIX, COUNT_TEN, COUNT_THOUSAND, COUNT_TWENTY, TEST_BEARER_TOKEN, } from '../../test-helpers/test-constants.js';
+const DEFAULT_MEMORY_WARNING_MB = COUNT_HUNDRED * COUNT_FOUR;
+const DEFAULT_MEMORY_ABORT_MB = COUNT_HUNDRED * COUNT_SIX;
+const MAX_ERROR_ENTRY_STRESS_EXCESS = COUNT_FIFTY;
+const MAX_ERROR_ENTRY_SMALL_EXCESS = COUNT_TEN;
+const ERROR_TRUNCATION_SUFFIX_MARGIN = COUNT_TWENTY;
+const LARGE_ERROR_BODY_OVERFLOW = COUNT_FIVE_THOUSAND;
+const MEDIUM_ERROR_BODY_OVERFLOW = COUNT_HUNDRED;
+const PREFIX_ERROR_BODY_OVERFLOW = COUNT_THOUSAND;
+describe('export-utils', () => {
+    describe('memory threshold configuration', () => {
+        let originalEnv;
+        beforeEach(() => {
+            originalEnv = { ...process.env };
+        });
+        afterEach(() => {
+            process.env = originalEnv;
+            // Note: ESM modules are cached, so we test default behavior here
+        });
+        it('uses default 400MB for MEMORY_WARNING_THRESHOLD_MB when env not set', async () => {
+            // Fresh import without env var (this tests the default case)
+            const { MEMORY_WARNING_THRESHOLD_MB } = await import('./export-utils.js');
+            // Default is 400 when EXPORT_MEMORY_WARN_MB is not set
+            assert.strictEqual(MEMORY_WARNING_THRESHOLD_MB, DEFAULT_MEMORY_WARNING_MB);
+        });
+        it('uses default 600MB for MEMORY_ABORT_THRESHOLD_MB when env not set', async () => {
+            const { MEMORY_ABORT_THRESHOLD_MB } = await import('./export-utils.js');
+            // Default is 600 when EXPORT_MEMORY_ABORT_MB is not set
+            assert.strictEqual(MEMORY_ABORT_THRESHOLD_MB, DEFAULT_MEMORY_ABORT_MB);
+        });
+        it('checkMemoryUsage returns correct structure', async () => {
+            const { checkMemoryUsage } = await import('./export-utils.js');
+            const status = checkMemoryUsage();
+            assert.ok(typeof status.heapUsedMB === 'number');
+            assert.ok(status.heapUsedMB >= 0);
+            assert.ok(typeof status.shouldWarn === 'boolean');
+            assert.ok(typeof status.shouldAbort === 'boolean');
+        });
+        it('checkMemoryUsage shouldWarn is based on threshold', async () => {
+            const { checkMemoryUsage, MEMORY_WARNING_THRESHOLD_MB } = await import('./export-utils.js');
+            const status = checkMemoryUsage();
+            // shouldWarn should be true if heapUsedMB > threshold
+            assert.strictEqual(status.shouldWarn, status.heapUsedMB > MEMORY_WARNING_THRESHOLD_MB);
+        });
+        it('checkMemoryUsage shouldAbort is based on threshold', async () => {
+            const { checkMemoryUsage, MEMORY_ABORT_THRESHOLD_MB } = await import('./export-utils.js');
+            const status = checkMemoryUsage();
+            // shouldAbort should be true if heapUsedMB > threshold
+            assert.strictEqual(status.shouldAbort, status.heapUsedMB > MEMORY_ABORT_THRESHOLD_MB);
+        });
+    });
+    describe('memory threshold parsing', () => {
+        // Test the parsing logic directly by verifying the module behavior
+        // Note: Due to ESM caching, we can't easily test env var changes at runtime
+        // These tests verify the default behavior and structure
+        it('exports MEMORY_WARNING_THRESHOLD_MB as number', async () => {
+            const { MEMORY_WARNING_THRESHOLD_MB } = await import('./export-utils.js');
+            assert.strictEqual(typeof MEMORY_WARNING_THRESHOLD_MB, 'number');
+            assert.ok(!isNaN(MEMORY_WARNING_THRESHOLD_MB));
+            assert.ok(MEMORY_WARNING_THRESHOLD_MB >= 1);
+        });
+        it('exports MEMORY_ABORT_THRESHOLD_MB as number', async () => {
+            const { MEMORY_ABORT_THRESHOLD_MB } = await import('./export-utils.js');
+            assert.strictEqual(typeof MEMORY_ABORT_THRESHOLD_MB, 'number');
+            assert.ok(!isNaN(MEMORY_ABORT_THRESHOLD_MB));
+            assert.ok(MEMORY_ABORT_THRESHOLD_MB >= 1);
+        });
+        it('abort threshold should be greater than or equal to warn threshold', async () => {
+            const { MEMORY_WARNING_THRESHOLD_MB, MEMORY_ABORT_THRESHOLD_MB } = await import('./export-utils.js');
+            // With defaults: 400 < 600
+            assert.ok(MEMORY_ABORT_THRESHOLD_MB >= MEMORY_WARNING_THRESHOLD_MB, `Abort threshold (${MEMORY_ABORT_THRESHOLD_MB}) should be >= warn threshold (${MEMORY_WARNING_THRESHOLD_MB})`);
+        });
+    });
+    describe('sanitizeErrorText', () => {
+        it('redacts Basic auth headers', async () => {
+            const { sanitizeErrorText } = await import('./export-utils.js');
+            const text = 'Error: Basic dXNlcjpwYXNzd29yZA== invalid';
+            const result = sanitizeErrorText(text);
+            assert.ok(!result.includes('dXNlcjpwYXNzd29yZA=='));
+            assert.ok(result.includes('[REDACTED]'));
+        });
+        it('redacts Bearer tokens', async () => {
+            const { sanitizeErrorText } = await import('./export-utils.js');
+            const text = `Error: Bearer ${TEST_BEARER_TOKEN} invalid`;
+            const result = sanitizeErrorText(text);
+            assert.ok(!result.includes(TEST_BEARER_TOKEN));
+            assert.ok(result.includes('[REDACTED]'));
+        });
+        it('redacts Langfuse pk/sk patterns', async () => {
+            const { sanitizeErrorText } = await import('./export-utils.js');
+            const text = 'Error with pk-lf-abc123:sk-lf-xyz789';
+            const result = sanitizeErrorText(text);
+            assert.ok(!result.includes('pk-lf-abc123:sk-lf-xyz789'));
+            assert.ok(result.includes('[REDACTED]'));
+        });
+        it('redacts Confident AI API keys', async () => {
+            const { sanitizeErrorText } = await import('./export-utils.js');
+            const text = 'Error with key confident_us_abc123xyz456789012345';
+            const result = sanitizeErrorText(text);
+            assert.ok(!result.includes('confident_us_abc123xyz456789012345'));
+            assert.ok(result.includes('[REDACTED]'));
+        });
+        it('redacts DD-API-KEY headers', async () => {
+            const { sanitizeErrorText } = await import('./export-utils.js');
+            const text = 'Header DD-API-KEY: abc123secret456';
+            const result = sanitizeErrorText(text);
+            assert.ok(!result.includes('abc123secret456'));
+            assert.ok(result.includes('[REDACTED]'));
+        });
+    });
+    describe('validateExternalUrl', () => {
+        it('rejects HTTP by default', async () => {
+            const { validateExternalUrl } = await import('./export-utils.js');
+            const result = validateExternalUrl('http://example.com');
+            assert.strictEqual(result, '');
+        });
+        it('accepts HTTPS by default', async () => {
+            const { validateExternalUrl } = await import('./export-utils.js');
+            const result = validateExternalUrl('https://example.com');
+            assert.strictEqual(result, 'https://example.com');
+        });
+        it('allows HTTP when explicitly enabled', async () => {
+            const { validateExternalUrl } = await import('./export-utils.js');
+            const result = validateExternalUrl('http://example.com', { allowHttp: true });
+            assert.strictEqual(result, 'http://example.com');
+        });
+        it('rejects localhost by default', async () => {
+            const { validateExternalUrl } = await import('./export-utils.js');
+            const result = validateExternalUrl('https://localhost:8080');
+            assert.strictEqual(result, '');
+        });
+        it('allows localhost when explicitly enabled', async () => {
+            const { validateExternalUrl } = await import('./export-utils.js');
+            const result = validateExternalUrl('https://localhost:8080', { allowLocalhost: true });
+            assert.strictEqual(result, 'https://localhost:8080');
+        });
+        it('rejects private network ranges', async () => {
+            const { validateExternalUrl } = await import('./export-utils.js');
+            assert.strictEqual(validateExternalUrl('https://192.168.1.1'), '');
+            assert.strictEqual(validateExternalUrl('https://10.0.0.1'), '');
+            assert.strictEqual(validateExternalUrl('https://172.16.0.1'), '');
+        });
+        it('rejects cloud metadata endpoint', async () => {
+            const { validateExternalUrl } = await import('./export-utils.js');
+            const result = validateExternalUrl('https://169.254.169.254');
+            assert.strictEqual(result, '');
+        });
+        it('preserves path for subpath installations', async () => {
+            const { validateExternalUrl } = await import('./export-utils.js');
+            const result = validateExternalUrl('https://example.com/api/v1');
+            assert.strictEqual(result, 'https://example.com/api/v1');
+        });
+        it('strips trailing slash', async () => {
+            const { validateExternalUrl } = await import('./export-utils.js');
+            const result = validateExternalUrl('https://example.com/api/');
+            assert.strictEqual(result, 'https://example.com/api');
+        });
+    });
+    describe('isValidTimestamp', () => {
+        it('accepts timestamp in valid range', async () => {
+            const { isValidTimestamp } = await import('./export-utils.js');
+            const now = Date.now();
+            assert.strictEqual(isValidTimestamp(now), true);
+        });
+        it('rejects timestamp before year 2000', async () => {
+            const { isValidTimestamp } = await import('./export-utils.js');
+            const pre2000 = new Date('1999-12-31T23:59:59Z').getTime();
+            assert.strictEqual(isValidTimestamp(pre2000), false);
+        });
+        it('rejects timestamp after year 3000', async () => {
+            const { isValidTimestamp } = await import('./export-utils.js');
+            const post3000 = new Date('3001-01-01T00:00:00Z').getTime();
+            assert.strictEqual(isValidTimestamp(post3000), false);
+        });
+        it('rejects NaN', async () => {
+            const { isValidTimestamp } = await import('./export-utils.js');
+            assert.strictEqual(isValidTimestamp(NaN), false);
+        });
+    });
+    describe('generateHexId', () => {
+        it('generates hex string of correct length', async () => {
+            const { generateHexId } = await import('./export-utils.js');
+            const id = generateHexId(DD_SPAN_ID_LENGTH);
+            assert.strictEqual(id.length, DD_SPAN_ID_LENGTH);
+            assert.strictEqual(id.length, OTLP_SPAN_ID_LENGTH);
+            assert.ok(/^[0-9a-f]+$/.test(id));
+        });
+        it('generates different IDs on each call', async () => {
+            const { generateHexId } = await import('./export-utils.js');
+            const id1 = generateHexId(DD_TRACE_ID_LENGTH);
+            const id2 = generateHexId(OTLP_TRACE_ID_LENGTH);
+            assert.notStrictEqual(id1, id2);
+        });
+    });
+    describe('isLocalhostAddress', () => {
+        it('identifies localhost', async () => {
+            const { isLocalhostAddress } = await import('./export-utils.js');
+            assert.strictEqual(isLocalhostAddress('localhost'), true);
+        });
+        it('identifies 127.0.0.1', async () => {
+            const { isLocalhostAddress } = await import('./export-utils.js');
+            assert.strictEqual(isLocalhostAddress('127.0.0.1'), true);
+        });
+        it('identifies 127.x.x.x variants', async () => {
+            const { isLocalhostAddress } = await import('./export-utils.js');
+            assert.strictEqual(isLocalhostAddress('127.0.0.2'), true);
+            assert.strictEqual(isLocalhostAddress('127.255.255.255'), true);
+        });
+        it('identifies 0.0.0.0', async () => {
+            const { isLocalhostAddress } = await import('./export-utils.js');
+            assert.strictEqual(isLocalhostAddress('0.0.0.0'), true);
+        });
+        it('identifies IPv6 localhost (::1)', async () => {
+            const { isLocalhostAddress } = await import('./export-utils.js');
+            assert.strictEqual(isLocalhostAddress('::1'), true);
+            assert.strictEqual(isLocalhostAddress('0:0:0:0:0:0:0:1'), true);
+        });
+        it('identifies IPv4-mapped IPv6 localhost', async () => {
+            const { isLocalhostAddress } = await import('./export-utils.js');
+            assert.strictEqual(isLocalhostAddress('::ffff:127.0.0.1'), true);
+        });
+        it('identifies .localhost subdomains', async () => {
+            const { isLocalhostAddress } = await import('./export-utils.js');
+            assert.strictEqual(isLocalhostAddress('app.localhost'), true);
+            assert.strictEqual(isLocalhostAddress('subdomain.localhost'), true);
+        });
+        it('handles bracketed IPv6', async () => {
+            const { isLocalhostAddress } = await import('./export-utils.js');
+            assert.strictEqual(isLocalhostAddress('[::1]'), true);
+        });
+        it('handles IPv6 zone identifiers', async () => {
+            const { isLocalhostAddress } = await import('./export-utils.js');
+            // Zone identifier is stripped before comparison
+            assert.strictEqual(isLocalhostAddress('::1%eth0'), true);
+        });
+        it('rejects external hostnames', async () => {
+            const { isLocalhostAddress } = await import('./export-utils.js');
+            assert.strictEqual(isLocalhostAddress('example.com'), false);
+            assert.strictEqual(isLocalhostAddress('api.langfuse.com'), false);
+        });
+        it('rejects private network addresses', async () => {
+            const { isLocalhostAddress } = await import('./export-utils.js');
+            assert.strictEqual(isLocalhostAddress('192.168.1.1'), false);
+            assert.strictEqual(isLocalhostAddress('10.0.0.1'), false);
+        });
+    });
+    describe('pushCappedError', () => {
+        it('adds errors until MAX_ERROR_ENTRIES', async () => {
+            const { pushCappedError } = await import('./export-utils.js');
+            const { MAX_ERROR_ENTRIES } = await import('../core/constants.js');
+            const errors = [];
+            for (let i = 0; i < MAX_ERROR_ENTRIES + MAX_ERROR_ENTRY_STRESS_EXCESS; i++) {
+                pushCappedError(errors, `Error ${i}`);
+            }
+            // Should have MAX_ERROR_ENTRIES + 1 (truncation message)
+            assert.strictEqual(errors.length, MAX_ERROR_ENTRIES + 1);
+        });
+        it('includes truncation message at cap', async () => {
+            const { pushCappedError } = await import('./export-utils.js');
+            const { MAX_ERROR_ENTRIES } = await import('../core/constants.js');
+            const errors = [];
+            for (let i = 0; i < MAX_ERROR_ENTRIES + MAX_ERROR_ENTRY_SMALL_EXCESS; i++) {
+                pushCappedError(errors, `Error ${i}`);
+            }
+            // Last entry should be truncation message
+            const lastError = errors[errors.length - 1];
+            assert.ok(lastError.includes('truncated'));
+            assert.ok(lastError.includes(String(MAX_ERROR_ENTRIES)));
+        });
+        it('preserves first errors', async () => {
+            const { pushCappedError } = await import('./export-utils.js');
+            const errors = [];
+            pushCappedError(errors, 'First error');
+            pushCappedError(errors, 'Second error');
+            assert.strictEqual(errors[0], 'First error');
+            assert.strictEqual(errors[1], 'Second error');
+        });
+        it('does not add duplicates after truncation message', async () => {
+            const { pushCappedError } = await import('./export-utils.js');
+            const { MAX_ERROR_ENTRIES } = await import('../core/constants.js');
+            const errors = [];
+            // Fill to capacity + add truncation
+            for (let i = 0; i < MAX_ERROR_ENTRIES + 1; i++) {
+                pushCappedError(errors, `Error ${i}`);
+            }
+            const lengthAfterTruncation = errors.length;
+            // Try to add more
+            pushCappedError(errors, 'This should not be added');
+            pushCappedError(errors, 'This also should not be added');
+            assert.strictEqual(errors.length, lengthAfterTruncation);
+        });
+    });
+    describe('truncateErrorBody', () => {
+        it('returns short text unchanged', async () => {
+            const { truncateErrorBody } = await import('./export-utils.js');
+            const text = 'Short error message';
+            const result = truncateErrorBody(text);
+            assert.strictEqual(result, text);
+        });
+        it('truncates text exceeding MAX_ERROR_BODY_SIZE', async () => {
+            const { truncateErrorBody } = await import('./export-utils.js');
+            const { MAX_ERROR_BODY_SIZE } = await import('../core/constants.js');
+            const large = 'x'.repeat(MAX_ERROR_BODY_SIZE + LARGE_ERROR_BODY_OVERFLOW);
+            const result = truncateErrorBody(large);
+            // Should be truncated with indicator
+            assert.ok(result.length <= MAX_ERROR_BODY_SIZE + ERROR_TRUNCATION_SUFFIX_MARGIN); // Allow for truncation suffix
+            assert.ok(result.includes('[truncated]'));
+        });
+        it('includes truncation indicator', async () => {
+            const { truncateErrorBody } = await import('./export-utils.js');
+            const { MAX_ERROR_BODY_SIZE } = await import('../core/constants.js');
+            const large = 'a'.repeat(MAX_ERROR_BODY_SIZE + MEDIUM_ERROR_BODY_OVERFLOW);
+            const result = truncateErrorBody(large);
+            assert.ok(result.endsWith('... [truncated]'));
+        });
+        it('preserves beginning of text', async () => {
+            const { truncateErrorBody } = await import('./export-utils.js');
+            const { MAX_ERROR_BODY_SIZE } = await import('../core/constants.js');
+            const prefix = 'IMPORTANT_PREFIX:';
+            const large = prefix + 'x'.repeat(MAX_ERROR_BODY_SIZE + PREFIX_ERROR_BODY_OVERFLOW);
+            const result = truncateErrorBody(large);
+            assert.ok(result.startsWith(prefix));
+        });
+        it('handles exactly MAX_ERROR_BODY_SIZE length', async () => {
+            const { truncateErrorBody } = await import('./export-utils.js');
+            const { MAX_ERROR_BODY_SIZE } = await import('../core/constants.js');
+            const exact = 'y'.repeat(MAX_ERROR_BODY_SIZE);
+            const result = truncateErrorBody(exact);
+            assert.strictEqual(result, exact); // Should not truncate
+        });
+        it('handles empty string', async () => {
+            const { truncateErrorBody } = await import('./export-utils.js');
+            const result = truncateErrorBody('');
+            assert.strictEqual(result, '');
+        });
+    });
+});
+//# sourceMappingURL=export-utils.test.js.map