observability-toolkit 1.8.0 → 1.8.4

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

@@ -1,40 +1,22 @@
-import { describe, it, beforeEach, afterEach } from 'node:test';
+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 * as os from 'os';
 import { LocalJsonlBackend, MultiDirectoryBackend } from './local-jsonl.js';
-import { buildAndWriteIndex } from '../lib/indexer.js';
-/**
- * Test utilities for creating temp test fixtures
- */
-function createTempDir() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), 'local-jsonl-test-'));
-}
-function removeTempDir(dir) {
-    try {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-    catch {
-        // Ignore cleanup errors
-    }
-}
-function writeJsonlFile(filePath, data) {
-    const content = data.map(item => JSON.stringify(item)).join('\n');
-    fs.writeFileSync(filePath, content, 'utf-8');
-}
-function getTestDate() {
-    return new Date().toISOString().split('T')[0];
-}
+import { buildAndWriteIndex, getIndexPath } from '../lib/indexer.js';
+import { createTempDir, removeTempDir, getSharedTempDir, clearTempDir, removeSharedTempDir, writeJsonlFile, getTestDate } from '../test-helpers/file-utils.js';
 describe('LocalJsonlBackend', () => {
     let tempDir;
     let backend;
+    before(() => {
+        tempDir = getSharedTempDir('LocalJsonlBackend');
+    });
     beforeEach(() => {
-        tempDir = createTempDir();
+        clearTempDir(tempDir);
         backend = new LocalJsonlBackend(tempDir);
     });
-    afterEach(() => {
-        removeTempDir(tempDir);
+    after(() => {
+        removeSharedTempDir('LocalJsonlBackend');
     });
     describe('queryTraces', () => {
         it('should read and normalize trace spans from JSONL files', async () => {
@@ -2664,6 +2646,269 @@ describe('LocalJsonlBackend', () => {
             const results = await backend.queryLLMEvents({ provider: 'anthropic-new' });
             assert.strictEqual(results.length, 3);
         });
+        it('should filter OpenAI events by provider', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'openai',
+                        'gen_ai.request.model': 'gpt-4o',
+                        'gen_ai.usage.input_tokens': 500,
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'anthropic',
+                        'gen_ai.request.model': 'claude-3-opus',
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({ provider: 'openai' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.request.model'], 'gpt-4o');
+        });
+        it('should filter Google Gemini events by provider', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'gcp.gemini',
+                        'gen_ai.request.model': 'gemini-1.5-pro',
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'gcp.vertex_ai',
+                        'gen_ai.request.model': 'gemini-pro',
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:02:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'openai',
+                        'gen_ai.request.model': 'gpt-4',
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const geminiResults = await backend.queryLLMEvents({ provider: 'gcp.gemini' });
+            assert.strictEqual(geminiResults.length, 1);
+            assert.strictEqual(geminiResults[0].attributes?.['gen_ai.request.model'], 'gemini-1.5-pro');
+            const vertexResults = await backend.queryLLMEvents({ provider: 'gcp.vertex_ai' });
+            assert.strictEqual(vertexResults.length, 1);
+        });
+        it('should filter Mistral AI events by provider', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'mistral_ai',
+                        'gen_ai.request.model': 'mistral-large',
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'anthropic',
+                        'gen_ai.request.model': 'claude-3',
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({ provider: 'mistral_ai' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.request.model'], 'mistral-large');
+        });
+        it('should filter AWS Bedrock events by provider', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'aws.bedrock',
+                        'gen_ai.request.model': 'anthropic.claude-3-sonnet-20240229-v1:0',
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'anthropic',
+                        'gen_ai.request.model': 'claude-3-sonnet',
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({ provider: 'aws.bedrock' });
+            assert.strictEqual(results.length, 1);
+            assert.ok(results[0].attributes?.['gen_ai.request.model']?.toString().includes('anthropic.claude'));
+        });
+        it('should filter Cohere events by provider', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'cohere',
+                        'gen_ai.request.model': 'command-r-plus',
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'openai',
+                        'gen_ai.request.model': 'gpt-4',
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({ provider: 'cohere' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.request.model'], 'command-r-plus');
+        });
+        it('should filter Groq events by provider', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'groq',
+                        'gen_ai.request.model': 'llama-3.3-70b',
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'together_ai',
+                        'gen_ai.request.model': 'llama-3-70b',
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const groqResults = await backend.queryLLMEvents({ provider: 'groq' });
+            assert.strictEqual(groqResults.length, 1);
+            assert.strictEqual(groqResults[0].attributes?.['gen_ai.request.model'], 'llama-3.3-70b');
+            const togetherResults = await backend.queryLLMEvents({ provider: 'together_ai' });
+            assert.strictEqual(togetherResults.length, 1);
+        });
+        it('should filter Ollama local model events by provider', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'ollama',
+                        'gen_ai.request.model': 'llama3:8b',
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'openai',
+                        'gen_ai.request.model': 'gpt-4',
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({ provider: 'ollama' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.request.model'], 'llama3:8b');
+        });
+        it('should filter custom/internal provider events', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'custom-internal-llm',
+                        'gen_ai.request.model': 'internal-model-v2',
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'anthropic',
+                        'gen_ai.request.model': 'claude-3',
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({ provider: 'custom-internal-llm' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.request.model'], 'internal-model-v2');
+        });
+        it('should combine provider and model filters', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'openai',
+                        'gen_ai.request.model': 'gpt-4o',
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'openai',
+                        'gen_ai.request.model': 'gpt-4-turbo',
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:02:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'anthropic',
+                        'gen_ai.request.model': 'gpt-4o', // Same model name, different provider
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({ provider: 'openai', model: 'gpt-4o' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.provider.name'], 'openai');
+            assert.strictEqual(results[0].attributes?.['gen_ai.request.model'], 'gpt-4o');
+        });
+        it('should return empty array when provider has no events', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.completion',
+                    attributes: {
+                        'gen_ai.provider.name': 'anthropic',
+                        'gen_ai.request.model': 'claude-3',
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({ provider: 'nonexistent-provider' });
+            assert.strictEqual(results.length, 0);
+        });
         it('should filter events by operationName', async () => {
             const today = getTestDate();
             const mockEvents = [
@@ -3175,12 +3420,15 @@ describe('streaming JSONL optimization', () => {
 describe('QueryCache', () => {
     let tempDir;
     let backend;
+    before(() => {
+        tempDir = getSharedTempDir('QueryCache');
+    });
     beforeEach(() => {
-        tempDir = createTempDir();
+        clearTempDir(tempDir);
         backend = new LocalJsonlBackend(tempDir);
     });
-    afterEach(() => {
-        removeTempDir(tempDir);
+    after(() => {
+        removeSharedTempDir('QueryCache');
     });
     describe('caching behavior', () => {
         it('should return cached results on second query with same options', async () => {
@@ -3459,12 +3707,15 @@ describe('QueryCache', () => {
 });
 describe('MultiDirectoryBackend', () => {
     let projectDir;
+    before(() => {
+        projectDir = getSharedTempDir('MultiDirectoryBackend');
+    });
     beforeEach(() => {
-        // Create a project directory that will have local telemetry subdirectories
-        projectDir = createTempDir();
+        // Clear project directory for each test
+        clearTempDir(projectDir);
     });
-    afterEach(() => {
-        removeTempDir(projectDir);
+    after(() => {
+        removeSharedTempDir('MultiDirectoryBackend');
     });
     describe('constructor and getDirectories', () => {
         it('should return directories when local telemetry dirs exist', () => {
@@ -3474,8 +3725,9 @@ describe('MultiDirectoryBackend', () => {
             const backend = new MultiDirectoryBackend(projectDir);
             const dirs = backend.getDirectories();
             assert.ok(Array.isArray(dirs));
-            // Should include the local telemetry directory
-            const localDir = dirs.find(d => d.source === 'local' && d.path === localTelemetry);
+            // Should include the local telemetry directory (resolved path due to symlink protection)
+            const resolvedPath = fs.realpathSync(localTelemetry);
+            const localDir = dirs.find(d => d.source === 'local' && d.path === resolvedPath);
             assert.ok(localDir);
         });
         it('should have name property set to multi-directory', () => {
@@ -3487,7 +3739,9 @@ describe('MultiDirectoryBackend', () => {
             fs.mkdirSync(localTelemetry, { recursive: true });
             const backend = new MultiDirectoryBackend(projectDir);
             const dirs = backend.getDirectories();
-            const localDir = dirs.find(d => d.path === localTelemetry);
+            // Compare against resolved path (due to symlink protection)
+            const resolvedPath = fs.realpathSync(localTelemetry);
+            const localDir = dirs.find(d => d.path === resolvedPath);
             assert.ok(localDir);
             assert.strictEqual(localDir?.source, 'local');
         });
@@ -3496,7 +3750,9 @@ describe('MultiDirectoryBackend', () => {
             fs.mkdirSync(localTelemetry, { recursive: true });
             const backend = new MultiDirectoryBackend(projectDir);
             const dirs = backend.getDirectories();
-            const localDir = dirs.find(d => d.path === localTelemetry);
+            // Compare against resolved path (due to symlink protection)
+            const resolvedPath = fs.realpathSync(localTelemetry);
+            const localDir = dirs.find(d => d.path === resolvedPath);
             assert.ok(localDir);
             assert.strictEqual(localDir?.source, 'local');
         });
@@ -3735,17 +3991,15 @@ describe('MultiDirectoryBackend', () => {
 describe('OTLP Export', () => {
     let tempDir;
     let backend;
+    before(() => {
+        tempDir = getSharedTempDir('OTLPExport');
+    });
     beforeEach(() => {
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'otlp-export-test-'));
+        clearTempDir(tempDir);
         backend = new LocalJsonlBackend(tempDir);
     });
-    afterEach(() => {
-        try {
-            fs.rmSync(tempDir, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
+    after(() => {
+        removeSharedTempDir('OTLPExport');
     });
     describe('exportTracesOTLP', () => {
         it('should export traces in OTLP JSON format', async () => {
@@ -3970,5 +4224,428 @@ describe('OTLP Export', () => {
             assert.strictEqual(dataPoint.exemplars[0].asDouble, 150);
         });
     });
+    describe('queryEvaluations', () => {
+        it('should read and normalize evaluations from JSONL files', async () => {
+            const today = getTestDate();
+            const mockEvaluations = [
+                {
+                    timestamp: '2026-01-29T10:00:00Z',
+                    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',
+                    },
+                },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Relevance' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Faithfulness' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'RelevanceScore' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.3 } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.7 } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.9 } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.3 } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.7 } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.9 } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.3 } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.5 } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.7 } },
+                { timestamp: '2026-01-29T10:03:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.9 } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'ToolCorrectness', 'gen_ai.evaluation.score.label': 'pass' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.score.value': 0.8 } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.score.value': 0.3 } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': 'pass' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': 'fail' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': 'pass' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.response.id': 'resp-123' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.response.id': 'resp-456' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.response.id': 'resp-123' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', traceId: 'trace-abc', attributes: { 'gen_ai.evaluation.name': 'Test' } },
+                { timestamp: '2026-01-29T10:01:00Z', traceId: 'trace-xyz', attributes: { 'gen_ai.evaluation.name': 'Test' } },
+                { timestamp: '2026-01-29T10:02:00Z', traceId: 'trace-abc', attributes: { 'gen_ai.evaluation.name': 'Test' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'session.id': 'sess-111' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'session.id': 'sess-222' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'session.id': 'sess-111' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Valid' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.score.value': 0.5 } }, // Missing name
+                { timestamp: '2026-01-29T10:02:00Z', attributes: {} }, // Empty
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': 'pass' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': '' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.label': '   ' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = Array.from({ length: 10 }, (_, i) => ({
+                timestamp: `2026-01-29T10:${String(i).padStart(2, '0')}:00Z`,
+                attributes: { 'gen_ai.evaluation.name': `Eval${i}` },
+            }));
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.score.label': 'pass' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Faithfulness', 'gen_ai.evaluation.score.label': 'fail' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.score.label': 'pass' } },
+            ];
+            const filePath = path.join(tempDir, `evaluations-${today}.jsonl`);
+            writeJsonlFile(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];
+            // Write files for both days
+            writeJsonlFile(path.join(tempDir, `evaluations-${today}.jsonl`), [
+                { timestamp: `${today}T10:00:00Z`, attributes: { 'gen_ai.evaluation.name': 'Today' } },
+            ]);
+            writeJsonlFile(path.join(tempDir, `evaluations-${yesterday}.jsonl`), [
+                { 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();
+            const mockEvaluations = [
+                {
+                    timestamp: '2026-01-29T10:00:00Z',
+                    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',
+                    },
+                },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'gpt-4-as-judge' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'human-reviewer' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'gpt-4-as-judge' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator.type': 'llm' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator.type': 'human' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator.type': 'llm' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test1', 'gen_ai.evaluation.evaluator.type': 'llm' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test2', 'gen_ai.evaluation.evaluator.type': 'human' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test3', 'gen_ai.evaluation.evaluator.type': 'rule' } },
+                { timestamp: '2026-01-29T10:03:00Z', attributes: { 'gen_ai.evaluation.name': 'Test4', 'gen_ai.evaluation.evaluator.type': 'classifier' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator.type': 'invalid' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator.type': 'LLM' } }, // Case matters
+            ];
+            writeJsonlFile(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();
+            const filePath = path.join(tempDir, `evaluations-${today}.jsonl`);
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.evaluator': 'gpt-4-as-judge' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Faithfulness', 'gen_ai.evaluation.evaluator': 'human-reviewer' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Relevance', 'gen_ai.evaluation.evaluator': 'gpt-4-as-judge' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': '' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': '   ' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'valid' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'gpt-4', 'gen_ai.evaluation.evaluator.type': 'llm' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'gpt-4', 'gen_ai.evaluation.evaluator.type': 'classifier' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.evaluator': 'claude', 'gen_ai.evaluation.evaluator.type': 'llm' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                {
+                    timestamp: '2026-01-29T10:00:00Z',
+                    attributes: {
+                        'gen_ai.evaluation.name': 'Relevance',
+                        'gen_ai.evaluation.score.value': 85,
+                        'gen_ai.evaluation.score.unit': 'percentage',
+                    },
+                },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test1', 'gen_ai.evaluation.score.value': 85, 'gen_ai.evaluation.score.unit': 'percentage' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test2', 'gen_ai.evaluation.score.value': 0.85, 'gen_ai.evaluation.score.unit': 'ratio_0_1' } },
+                { timestamp: '2026-01-29T10:02:00Z', attributes: { 'gen_ai.evaluation.name': 'Test3', 'gen_ai.evaluation.score.value': 4, 'gen_ai.evaluation.score.unit': 'stars_1_5' } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.85 } },
+            ];
+            writeJsonlFile(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();
+            const mockEvaluations = [
+                { timestamp: '2026-01-29T10:00:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.85, 'gen_ai.evaluation.score.unit': '' } },
+                { timestamp: '2026-01-29T10:01:00Z', attributes: { 'gen_ai.evaluation.name': 'Test', 'gen_ai.evaluation.score.value': 0.90, 'gen_ai.evaluation.score.unit': '   ' } },
+            ];
+            writeJsonlFile(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.test.js.map