observability-toolkit 1.8.4 → 1.8.5

package/dist/backends/local-jsonl-export.test.js

@@ -0,0 +1,704 @@
+import { describe, it, before, after, beforeEach } from 'node:test';
+import * as assert from 'node:assert';
+import * as fs from 'fs';
+import * as path from 'path';
+import { LocalJsonlBackend } from './local-jsonl.js';
+import { buildAndWriteIndex, getIndexPath } from '../lib/indexer.js';
+import { getSharedTempDir, clearTempDir, removeSharedTempDir, writeJsonlFileAsync, getTestDate } from '../test-helpers/file-utils.js';
+import { createMockSpan, createMockLog, createMockMetric, createMockEvaluation, createMockEvaluations, resetBuilderCounters, TEST_TIMESTAMP, TEST_TIMESTAMP_ISO, } from '../test-helpers/test-data-builders.js';
+describe('OTLP Export', () => {
+    let tempDir;
+    let backend;
+    before(() => {
+        tempDir = getSharedTempDir('OTLPExport');
+    });
+    beforeEach(() => {
+        clearTempDir(tempDir);
+        backend = new LocalJsonlBackend(tempDir);
+    });
+    after(() => {
+        removeSharedTempDir('OTLPExport');
+    });
+    describe('exportTracesOTLP', () => {
+        it('should export traces in OTLP JSON format', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockSpans = [
+                createMockSpan({
+                    traceId: 'trace1',
+                    spanId: 'span1',
+                    name: 'root-span',
+                    kind: 1, // SERVER
+                    startTime: [...TEST_TIMESTAMP],
+                    endTime: [1700000001, 500000000],
+                    status: { code: 1, message: 'OK' },
+                    resource: { serviceName: 'test-service', serviceVersion: '1.0.0' },
+                    attributes: { 'http.method': 'GET', 'http.status_code': 200 },
+                }),
+                createMockSpan({
+                    traceId: 'trace1',
+                    spanId: 'span2',
+                    name: 'db-query',
+                    kind: 2, // CLIENT
+                    startTime: [1700000000, 100000000],
+                    endTime: [1700000000, 500000000],
+                    status: { code: 1 },
+                    resource: { serviceName: 'test-service' },
+                    attributes: { 'db.system': 'postgresql' },
+                }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
+            const otlp = await backend.exportTracesOTLP({});
+            assert.ok(otlp.resourceSpans);
+            assert.strictEqual(otlp.resourceSpans.length, 1);
+            const resourceSpan = otlp.resourceSpans[0];
+            assert.ok(resourceSpan.resource);
+            assert.ok(resourceSpan.resource.attributes.some((a) => a.key === 'service.name' && a.value.stringValue === 'test-service'));
+            assert.ok(resourceSpan.scopeSpans);
+            assert.strictEqual(resourceSpan.scopeSpans.length, 1);
+            const scopeSpan = resourceSpan.scopeSpans[0];
+            assert.strictEqual(scopeSpan.spans.length, 2);
+            const rootSpan = scopeSpan.spans.find((s) => s.name === 'root-span');
+            assert.ok(rootSpan);
+            assert.strictEqual(rootSpan.traceId, 'trace1');
+            assert.strictEqual(rootSpan.spanId, 'span1');
+            assert.strictEqual(rootSpan.kind, 1); // SERVER
+            assert.strictEqual(rootSpan.status?.code, 1);
+        });
+        it('should group spans by service name in OTLP export', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockSpans = [
+                createMockSpan({
+                    traceId: 'trace1',
+                    spanId: 'span1',
+                    name: 'service-a-op',
+                    resource: { serviceName: 'service-a' },
+                }),
+                createMockSpan({
+                    traceId: 'trace1',
+                    spanId: 'span2',
+                    name: 'service-b-op',
+                    resource: { serviceName: 'service-b' },
+                }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
+            const otlp = await backend.exportTracesOTLP({});
+            assert.strictEqual(otlp.resourceSpans.length, 2);
+            const serviceNames = otlp.resourceSpans.map((rs) => rs.resource.attributes.find((a) => a.key === 'service.name')?.value.stringValue);
+            assert.ok(serviceNames.includes('service-a'));
+            assert.ok(serviceNames.includes('service-b'));
+        });
+    });
+    describe('exportLogsOTLP', () => {
+        it('should export logs in OTLP JSON format', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockLogs = [
+                createMockLog({
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    severityText: 'ERROR',
+                    body: 'Database connection failed',
+                    traceId: 'trace1',
+                    spanId: 'span1',
+                    attributes: { 'error.type': 'ConnectionError' },
+                }),
+                createMockLog({
+                    timestamp: '2024-01-15T10:00:01.000Z',
+                    severityText: 'INFO',
+                    body: 'Request processed',
+                }),
+            ];
+            // Add resource separately as it's not part of MockLog interface
+            const mockLogsWithResource = mockLogs.map(log => ({
+                ...log,
+                resource: { serviceName: 'test-service' },
+            }));
+            await writeJsonlFileAsync(path.join(tempDir, `logs-${today}.jsonl`), mockLogsWithResource);
+            const otlp = await backend.exportLogsOTLP({});
+            assert.ok(otlp.resourceLogs);
+            assert.strictEqual(otlp.resourceLogs.length, 1);
+            const resourceLog = otlp.resourceLogs[0];
+            assert.ok(resourceLog.resource);
+            assert.ok(resourceLog.resource.attributes.some((a) => a.key === 'service.name' && a.value.stringValue === 'test-service'));
+            assert.ok(resourceLog.scopeLogs);
+            const scopeLog = resourceLog.scopeLogs[0];
+            assert.strictEqual(scopeLog.logRecords.length, 2);
+            const errorLog = scopeLog.logRecords.find((l) => l.severityText === 'ERROR');
+            assert.ok(errorLog);
+            assert.ok(errorLog.body?.stringValue?.includes('Database connection failed'));
+            assert.strictEqual(errorLog.traceId, 'trace1');
+            assert.strictEqual(errorLog.spanId, 'span1');
+            assert.strictEqual(errorLog.severityNumber, 17); // ERROR severity number
+        });
+    });
+    describe('exportMetricsOTLP', () => {
+        it('should export gauge metrics in OTLP JSON format', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    name: 'cpu.utilization',
+                    value: 75.5,
+                    type: 'gauge',
+                    unit: 'percent',
+                    resource: { serviceName: 'test-service' },
+                    attributes: { 'host.name': 'server1' },
+                }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const otlp = await backend.exportMetricsOTLP({});
+            assert.ok(otlp.resourceMetrics);
+            assert.strictEqual(otlp.resourceMetrics.length, 1);
+            const resourceMetric = otlp.resourceMetrics[0];
+            assert.ok(resourceMetric.scopeMetrics);
+            const metric = resourceMetric.scopeMetrics[0].metrics[0];
+            assert.strictEqual(metric.name, 'cpu.utilization');
+            assert.strictEqual(metric.unit, 'percent');
+            assert.ok(metric.gauge);
+            assert.strictEqual(metric.gauge.dataPoints.length, 1);
+            assert.strictEqual(metric.gauge.dataPoints[0].asDouble, 75.5);
+        });
+        it('should export counter metrics with aggregation temporality', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                {
+                    ...createMockMetric({
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        name: 'http.requests',
+                        value: 100,
+                        type: 'counter',
+                        unit: 'requests',
+                    }),
+                    aggregationTemporality: 2, // CUMULATIVE
+                    resource: { serviceName: 'test-service' },
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const otlp = await backend.exportMetricsOTLP({});
+            const metric = otlp.resourceMetrics[0].scopeMetrics[0].metrics[0];
+            assert.ok(metric.sum);
+            assert.strictEqual(metric.sum.aggregationTemporality, 2); // CUMULATIVE
+            assert.strictEqual(metric.sum.isMonotonic, true);
+        });
+        it('should export histogram metrics in OTLP JSON format', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                {
+                    ...createMockMetric({
+                        timestamp: '2024-01-15T10:00:00.000Z',
+                        name: 'http.request.duration',
+                        value: 250,
+                        type: 'histogram',
+                        unit: 'ms',
+                        histogram: {
+                            buckets: [
+                                { le: 10, count: 5 },
+                                { le: 50, count: 15 },
+                                { le: 100, count: 25 },
+                                { le: 500, count: 45 },
+                                { le: Infinity, count: 50 },
+                            ],
+                            sum: 12500,
+                            count: 50,
+                        },
+                    }),
+                    aggregationTemporality: 2,
+                    resource: { serviceName: 'test-service' },
+                },
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const otlp = await backend.exportMetricsOTLP({});
+            const metric = otlp.resourceMetrics[0].scopeMetrics[0].metrics[0];
+            assert.strictEqual(metric.name, 'http.request.duration');
+            assert.ok(metric.histogram);
+            assert.strictEqual(metric.histogram.aggregationTemporality, 2);
+            const dataPoint = metric.histogram.dataPoints[0];
+            assert.strictEqual(dataPoint.count, '50');
+            assert.strictEqual(dataPoint.sum, 12500);
+            assert.strictEqual(dataPoint.bucketCounts.length, 5);
+        });
+        it('should include exemplars in OTLP metric export', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockMetrics = [
+                createMockMetric({
+                    timestamp: '2024-01-15T10:00:00.000Z',
+                    name: 'http.latency',
+                    value: 150,
+                    type: 'gauge',
+                    unit: 'ms',
+                    resource: { serviceName: 'test-service' },
+                    exemplars: [
+                        {
+                            timestamp: '2024-01-15T10:00:00.000Z',
+                            value: 150,
+                            traceId: 'trace123',
+                            spanId: 'span456',
+                        },
+                    ],
+                }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
+            const otlp = await backend.exportMetricsOTLP({});
+            const dataPoint = otlp.resourceMetrics[0].scopeMetrics[0].metrics[0].gauge?.dataPoints[0];
+            assert.ok(dataPoint?.exemplars);
+            assert.strictEqual(dataPoint.exemplars.length, 1);
+            assert.strictEqual(dataPoint.exemplars[0].traceId, 'trace123');
+            assert.strictEqual(dataPoint.exemplars[0].spanId, 'span456');
+            assert.strictEqual(dataPoint.exemplars[0].asDouble, 150);
+        });
+    });
+    describe('queryEvaluations', () => {
+        it('should read and normalize evaluations from JSONL files', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({
+                    attributes: {
+                        'gen_ai.evaluation.name': 'Relevance',
+                        'gen_ai.evaluation.score.value': 0.92,
+                        'gen_ai.evaluation.score.label': 'relevant',
+                        'gen_ai.evaluation.explanation': 'Response addresses the query',
+                    },
+                }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].evaluationName, 'Relevance');
+            assert.strictEqual(results[0].scoreValue, 0.92);
+            assert.strictEqual(results[0].scoreLabel, 'relevant');
+            assert.strictEqual(results[0].explanation, 'Response addresses the query');
+        });
+        it('should filter evaluations by evaluationName substring', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Relevance' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Faithfulness' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'RelevanceScore' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ evaluationName: 'Relevance' });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.every(e => e.evaluationName.includes('Relevance')));
+        });
+        it('should filter evaluations by scoreMin threshold', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.3 } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.7 } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.9 } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ scoreMin: 0.5 });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.every(e => e.scoreValue >= 0.5));
+        });
+        it('should filter evaluations by scoreMax threshold', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.3 } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.7 } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.9 } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ scoreMax: 0.5 });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].scoreValue, 0.3);
+        });
+        it('should filter evaluations by score range', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.3 } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.5 } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.7 } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.9 } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ scoreMin: 0.4, scoreMax: 0.8 });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.some(e => e.scoreValue === 0.5));
+            assert.ok(results.some(e => e.scoreValue === 0.7));
+        });
+        it('should pass evaluations without scoreValue through score range filters (P1-1)', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'ToolCorrectness', 'gen_ai.evaluation.score.label': 'pass' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.score.value': 0.8 } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.score.value': 0.3 } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ scoreMin: 0.5 });
+            // Should include ToolCorrectness (no scoreValue) AND Relevance with 0.8
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.some(e => e.evaluationName === 'ToolCorrectness'));
+            assert.ok(results.some(e => e.scoreValue === 0.8));
+        });
+        it('should filter evaluations by scoreLabel exact match', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': 'pass' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': 'fail' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': 'pass' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ scoreLabel: 'pass' });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.every(e => e.scoreLabel === 'pass'));
+        });
+        it('should filter evaluations by responseId', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.response.id': 'resp-123' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.response.id': 'resp-456' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.response.id': 'resp-123' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ responseId: 'resp-123' });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.every(e => e.responseId === 'resp-123'));
+        });
+        it('should filter evaluations by traceId', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ traceId: 'trace-abc', attributes: { 'gen_ai.evaluation.name': 'Test' } }),
+                createMockEvaluation({ traceId: 'trace-xyz', attributes: { 'gen_ai.evaluation.name': 'Test' } }),
+                createMockEvaluation({ traceId: 'trace-abc', attributes: { 'gen_ai.evaluation.name': 'Test' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ traceId: 'trace-abc' });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.every(e => e.traceId === 'trace-abc'));
+        });
+        it('should filter evaluations by sessionId', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'session.id': 'sess-111' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'session.id': 'sess-222' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'session.id': 'sess-111' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ sessionId: 'sess-111' });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.every(e => e.sessionId === 'sess-111'));
+        });
+        it('should skip evaluations without required evaluationName', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Valid' } }),
+                { timestamp: TEST_TIMESTAMP_ISO, attributes: { 'gen_ai.evaluation.score.value': 0.5 } }, // Missing name - inline for invalid case
+                { timestamp: TEST_TIMESTAMP_ISO, attributes: {} }, // Empty - inline for invalid case
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].evaluationName, 'Valid');
+        });
+        it('should reject NaN and Infinity in scoreValue (P0-2)', async () => {
+            const today = getTestDate();
+            // Write raw JSONL with invalid numbers (simulating corrupted data)
+            const rawContent = [
+                JSON.stringify({ timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.5 } }),
+                '{"timestamp":"2026-01-29T10:01:00Z","attributes":{"gen_ai.evaluation.name":"NaNTest","gen_ai.evaluation.score.value":"NaN"}}',
+                JSON.stringify({ timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Valid', 'gen_ai.evaluation.score.value': 0.8 } }),
+            ].join('\n');
+            fs.writeFileSync(path.join(tempDir, `evaluations-${today}.jsonl`), rawContent, 'utf-8');
+            const results = await backend.queryEvaluations({});
+            // Should have 3 evaluations (NaNTest has scoreValue as string "NaN" so it becomes undefined, but evaluation itself is valid)
+            assert.strictEqual(results.length, 3);
+            // The NaNTest should have undefined scoreValue (string "NaN" is not a number type)
+            const nanTest = results.find(e => e.evaluationName === 'NaNTest');
+            assert.strictEqual(nanTest?.scoreValue, undefined);
+        });
+        it('should reject empty strings in scoreLabel (P0-2)', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': 'pass' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': '' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': '   ' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({});
+            assert.strictEqual(results.length, 3);
+            // Only first should have scoreLabel
+            assert.strictEqual(results[0].scoreLabel, 'pass');
+            assert.strictEqual(results[1].scoreLabel, undefined);
+            assert.strictEqual(results[2].scoreLabel, undefined);
+        });
+        it('should cache query results', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            // First query
+            const results1 = await backend.queryEvaluations({ evaluationName: 'Test' });
+            const stats1 = backend.getCacheStats();
+            // Second query (same params)
+            const results2 = await backend.queryEvaluations({ evaluationName: 'Test' });
+            const stats2 = backend.getCacheStats();
+            assert.deepStrictEqual(results1, results2);
+            assert.strictEqual(stats2.evaluations.hits, stats1.evaluations.hits + 1);
+        });
+        it('should apply limit and offset', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = createMockEvaluations(10, (i) => ({
+                timestamp: `2026-01-29T10:${String(i).padStart(2, '0')}:00Z`,
+                attributes: { 'gen_ai.evaluation.name': `Eval${i}` },
+            }));
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ limit: 3, offset: 2 });
+            assert.strictEqual(results.length, 3);
+            assert.strictEqual(results[0].evaluationName, 'Eval2');
+            assert.strictEqual(results[1].evaluationName, 'Eval3');
+            assert.strictEqual(results[2].evaluationName, 'Eval4');
+        });
+        it('should return empty array when no files found', async () => {
+            const results = await backend.queryEvaluations({});
+            assert.deepStrictEqual(results, []);
+        });
+        it('should use index when available', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.score.label': 'pass' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Faithfulness', 'gen_ai.evaluation.score.label': 'fail' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.score.label': 'pass' } }),
+            ];
+            const filePath = path.join(tempDir, `evaluations-${today}.jsonl`);
+            await writeJsonlFileAsync(filePath, mockEvaluations);
+            // Build index
+            await buildAndWriteIndex(filePath, 'evaluations');
+            // Verify index exists
+            const idxPath = getIndexPath(filePath);
+            assert.ok(fs.existsSync(idxPath));
+            // Query should use index
+            const results = await backend.queryEvaluations({ evaluationName: 'Relevance' });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.every(e => e.evaluationName === 'Relevance'));
+        });
+        it('should filter by date range', async () => {
+            const today = getTestDate();
+            const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+            resetBuilderCounters();
+            // Write files for both days
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), [
+                createMockEvaluation({ timestamp: `${today}T10:00:00Z`, attributes: { 'gen_ai.evaluation.name': 'Today' } }),
+            ]);
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${yesterday}.jsonl`), [
+                createMockEvaluation({ timestamp: `${yesterday}T10:00:00Z`, attributes: { 'gen_ai.evaluation.name': 'Yesterday' } }),
+            ]);
+            // Query only today
+            const results = await backend.queryEvaluations({ startDate: today, endDate: today });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].evaluationName, 'Today');
+        });
+        // Phase 3: evaluator field tests
+        it('should read and normalize evaluator and evaluatorType fields', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({
+                    attributes: {
+                        'gen_ai.evaluation.name': 'Relevance',
+                        'gen_ai.evaluation.score.value': 0.92,
+                        'gen_ai.evaluation.evaluator': 'gpt-4-as-judge',
+                        'gen_ai.evaluation.evaluator.type': 'llm',
+                    },
+                }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].evaluator, 'gpt-4-as-judge');
+            assert.strictEqual(results[0].evaluatorType, 'llm');
+        });
+        it('should filter evaluations by evaluator exact match', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'gpt-4-as-judge' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'human-reviewer' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'gpt-4-as-judge' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ evaluator: 'gpt-4-as-judge' });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.every(e => e.evaluator === 'gpt-4-as-judge'));
+        });
+        it('should filter evaluations by evaluatorType exact match', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator.type': 'llm' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator.type': 'human' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator.type': 'llm' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ evaluatorType: 'llm' });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.every(e => e.evaluatorType === 'llm'));
+        });
+        it('should handle all valid evaluatorType values', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test1', 'gen_ai.evaluation.evaluator.type': 'llm' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test2', 'gen_ai.evaluation.evaluator.type': 'human' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test3', 'gen_ai.evaluation.evaluator.type': 'rule' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test4', 'gen_ai.evaluation.evaluator.type': 'classifier' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({});
+            assert.strictEqual(results.length, 4);
+            // Results may not be in insertion order - check that all types are present
+            const types = results.map(r => r.evaluatorType).sort();
+            assert.deepStrictEqual(types, ['classifier', 'human', 'llm', 'rule']);
+        });
+        it('should reject invalid evaluatorType values', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator.type': 'invalid' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator.type': 'LLM' } }), // Case matters
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({});
+            assert.strictEqual(results.length, 2);
+            // Invalid types should be undefined
+            assert.strictEqual(results[0].evaluatorType, undefined);
+            assert.strictEqual(results[1].evaluatorType, 'llm'); // Normalized to lowercase
+        });
+        it('should use index when filtering by evaluator', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const filePath = path.join(tempDir, `evaluations-${today}.jsonl`);
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.evaluator': 'gpt-4-as-judge' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Faithfulness', 'gen_ai.evaluation.evaluator': 'human-reviewer' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.evaluator': 'gpt-4-as-judge' } }),
+            ];
+            await writeJsonlFileAsync(filePath, mockEvaluations);
+            // Build index
+            await buildAndWriteIndex(filePath, 'evaluations');
+            // Verify index exists
+            const idxPath = getIndexPath(filePath);
+            assert.ok(fs.existsSync(idxPath));
+            // Query should use index
+            const results = await backend.queryEvaluations({ evaluator: 'gpt-4-as-judge' });
+            assert.strictEqual(results.length, 2);
+            assert.ok(results.every(e => e.evaluator === 'gpt-4-as-judge'));
+        });
+        it('should handle empty evaluator string', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': '' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': '   ' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'valid' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({});
+            assert.strictEqual(results.length, 3);
+            // Empty and whitespace-only should be undefined
+            assert.strictEqual(results[0].evaluator, undefined);
+            assert.strictEqual(results[1].evaluator, undefined);
+            assert.strictEqual(results[2].evaluator, 'valid');
+        });
+        it('should filter by both evaluator and evaluatorType', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'gpt-4', 'gen_ai.evaluation.evaluator.type': 'llm' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'gpt-4', 'gen_ai.evaluation.evaluator.type': 'classifier' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'claude', 'gen_ai.evaluation.evaluator.type': 'llm' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({ evaluator: 'gpt-4', evaluatorType: 'llm' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].evaluator, 'gpt-4');
+            assert.strictEqual(results[0].evaluatorType, 'llm');
+        });
+        // Phase 1: scoreUnit field tests
+        it('should read and normalize scoreUnit field', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({
+                    attributes: {
+                        'gen_ai.evaluation.name': 'Relevance',
+                        'gen_ai.evaluation.score.value': 85,
+                        'gen_ai.evaluation.score.unit': 'percentage',
+                    },
+                }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].scoreValue, 85);
+            assert.strictEqual(results[0].scoreUnit, 'percentage');
+        });
+        it('should handle various scoreUnit values', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test1', 'gen_ai.evaluation.score.value': 85, 'gen_ai.evaluation.score.unit': 'percentage' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test2', 'gen_ai.evaluation.score.value': 0.85, 'gen_ai.evaluation.score.unit': 'ratio_0_1' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test3', 'gen_ai.evaluation.score.value': 4, 'gen_ai.evaluation.score.unit': 'stars_1_5' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({});
+            assert.strictEqual(results.length, 3);
+            // Results may not be in insertion order
+            const percentage = results.find(r => r.evaluationName === 'Test1');
+            const ratio = results.find(r => r.evaluationName === 'Test2');
+            const stars = results.find(r => r.evaluationName === 'Test3');
+            assert.strictEqual(percentage?.scoreUnit, 'percentage');
+            assert.strictEqual(ratio?.scoreUnit, 'ratio_0_1');
+            assert.strictEqual(stars?.scoreUnit, 'stars_1_5');
+        });
+        it('should handle missing scoreUnit', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.85 } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({});
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].scoreValue, 0.85);
+            assert.strictEqual(results[0].scoreUnit, undefined);
+        });
+        it('should handle empty scoreUnit string', async () => {
+            const today = getTestDate();
+            resetBuilderCounters();
+            const mockEvaluations = [
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.85, 'gen_ai.evaluation.score.unit': '' } }),
+                createMockEvaluation({ attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.90, 'gen_ai.evaluation.score.unit': '   ' } }),
+            ];
+            await writeJsonlFileAsync(path.join(tempDir, `evaluations-${today}.jsonl`), mockEvaluations);
+            const results = await backend.queryEvaluations({});
+            assert.strictEqual(results.length, 2);
+            // Empty and whitespace-only should be undefined
+            assert.ok(results.every(r => r.scoreUnit === undefined));
+        });
+    });
+});
+//# sourceMappingURL=local-jsonl-export.test.js.map