observability-toolkit 2.0.0 → 2.1.1

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

@@ -1,4651 +0,0 @@
-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, MultiDirectoryBackend } from './local-jsonl.js';
-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(() => {
-        clearTempDir(tempDir);
-        backend = new LocalJsonlBackend(tempDir);
-    });
-    after(() => {
-        removeSharedTempDir('LocalJsonlBackend');
-    });
-    describe('queryTraces', () => {
-        it('should read and normalize trace spans from JSONL files', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'test-operation',
-                    startTime: [1700000000, 0],
-                    endTime: [1700000001, 500000000],
-                    resource: { serviceName: 'test-service', serviceVersion: '1.0.0' },
-                    attributes: { 'custom.attr': 'value1' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-            assert.strictEqual(results[0].spanId, 'span1');
-            assert.strictEqual(results[0].name, 'test-operation');
-            assert.strictEqual(results[0].attributes?.['service.name'], 'test-service');
-            assert.strictEqual(results[0].attributes?.['service.version'], '1.0.0');
-            assert.strictEqual(results[0].attributes?.['custom.attr'], 'value1');
-        });
-        it('should filter spans by traceId', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'op2', startTime: [1700000000, 0] },
-                { traceId: 'trace1', spanId: 'span3', name: 'op3', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ traceId: 'trace1' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.every(s => s.traceId === 'trace1'));
-        });
-        it('should filter spans by spanName substring', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'user-create', startTime: [1700000000, 0] },
-                { traceId: 'trace1', spanId: 'span2', name: 'user-update', startTime: [1700000000, 0] },
-                { traceId: 'trace1', spanId: 'span3', name: 'db-query', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ spanName: 'user' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.every(s => s.name.includes('user')));
-        });
-        it('should filter spans by duration range', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'fast-op',
-                    startTime: [1700000000, 0],
-                    endTime: [1700000000, 500000000], // 0.5s
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    name: 'medium-op',
-                    startTime: [1700000000, 0],
-                    endTime: [1700000002, 0], // 2s
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span3',
-                    name: 'slow-op',
-                    startTime: [1700000000, 0],
-                    endTime: [1700000010, 0], // 10s
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ minDurationMs: 1000, maxDurationMs: 5000 });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'medium-op');
-        });
-        it('should filter spans by serviceName', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'op1',
-                    startTime: [1700000000, 0],
-                    resource: { serviceName: 'service-a' },
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    name: 'op2',
-                    startTime: [1700000000, 0],
-                    resource: { serviceName: 'service-b' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ serviceName: 'service-a' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes?.['service.name'], 'service-a');
-        });
-        it('should apply limit and offset to results', async () => {
-            const today = getTestDate();
-            const mockSpans = Array.from({ length: 150 }, (_, i) => ({
-                traceId: `trace${i}`,
-                spanId: `span${i}`,
-                name: `op${i}`,
-                startTime: [1700000000, 0],
-            }));
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ limit: 50, offset: 25 });
-            assert.strictEqual(results.length, 50);
-            assert.strictEqual(results[0].traceId, 'trace25');
-        });
-        it('should skip invalid spans (missing required fields)', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', startTime: [1700000000, 0] }, // missing name
-                { spanId: 'span3', name: 'op3', startTime: [1700000000, 0] }, // missing traceId
-                { traceId: 'trace4', name: 'op4', startTime: [1700000000, 0] }, // missing spanId
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should convert duration from [seconds, nanoseconds] array', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'op1',
-                    startTime: [1700000000, 0],
-                    duration: [2, 500000000], // 2.5 seconds
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].durationMs, 2500);
-        });
-        it('should convert span kind number to string', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'op1', kind: 0, startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'op2', kind: 1, startTime: [1700000000, 0] },
-                { traceId: 'trace3', spanId: 'span3', name: 'op3', kind: 2, startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results[0].kind, 'INTERNAL');
-            assert.strictEqual(results[1].kind, 'SERVER');
-            assert.strictEqual(results[2].kind, 'CLIENT');
-        });
-        it('should convert status code number to string', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'op1', startTime: [1700000000, 0], status: { code: 0 } },
-                { traceId: 'trace2', spanId: 'span2', name: 'op2', startTime: [1700000000, 0], status: { code: 1 } },
-                { traceId: 'trace3', spanId: 'span3', name: 'op3', startTime: [1700000000, 0], status: { code: 2, message: 'Test error' } },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results[0].statusCode, 'UNSET');
-            assert.strictEqual(results[0].status?.code, 0);
-            assert.strictEqual(results[1].statusCode, 'OK');
-            assert.strictEqual(results[1].status?.code, 1);
-            assert.strictEqual(results[2].statusCode, 'ERROR');
-            assert.strictEqual(results[2].status?.code, 2);
-            assert.strictEqual(results[2].status?.message, 'Test error');
-        });
-        it('should handle spans without status', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results[0].statusCode, undefined);
-            assert.strictEqual(results[0].status, undefined);
-        });
-        it('should extract instrumentationScope from spans', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    instrumentationScope: {
-                        name: '@opentelemetry/instrumentation-http',
-                        version: '0.48.0',
-                        schemaUrl: 'https://opentelemetry.io/schemas/1.21.0',
-                    },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'custom-span',
-                    startTime: [1700000000, 0],
-                    instrumentationScope: {
-                        name: 'custom-hooks',
-                    },
-                },
-                {
-                    traceId: 'trace3',
-                    spanId: 'span3',
-                    name: 'no-scope',
-                    startTime: [1700000000, 0],
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 3);
-            // First span: full scope
-            assert.strictEqual(results[0].instrumentationScope?.name, '@opentelemetry/instrumentation-http');
-            assert.strictEqual(results[0].instrumentationScope?.version, '0.48.0');
-            assert.strictEqual(results[0].instrumentationScope?.schemaUrl, 'https://opentelemetry.io/schemas/1.21.0');
-            // Second span: name only
-            assert.strictEqual(results[1].instrumentationScope?.name, 'custom-hooks');
-            assert.strictEqual(results[1].instrumentationScope?.version, undefined);
-            // Third span: no scope
-            assert.strictEqual(results[2].instrumentationScope, undefined);
-        });
-        it('should extract span links from spans', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'batch-processor',
-                    startTime: [1700000000, 0],
-                    links: [
-                        {
-                            context: { traceId: 'trace-upstream-1', spanId: 'span-upstream-1' },
-                            attributes: { 'link.type': 'producer' },
-                        },
-                        {
-                            context: { traceId: 'trace-upstream-2', spanId: 'span-upstream-2' },
-                        },
-                    ],
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'single-link',
-                    startTime: [1700000000, 0],
-                    links: [
-                        {
-                            context: { traceId: 'trace-parent', spanId: 'span-parent' },
-                            attributes: { 'link.reason': 'causal' },
-                        },
-                    ],
-                },
-                {
-                    traceId: 'trace3',
-                    spanId: 'span3',
-                    name: 'no-links',
-                    startTime: [1700000000, 0],
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 3);
-            // First span: multiple links
-            assert.strictEqual(results[0].links?.length, 2);
-            assert.strictEqual(results[0].links?.[0].traceId, 'trace-upstream-1');
-            assert.strictEqual(results[0].links?.[0].spanId, 'span-upstream-1');
-            assert.strictEqual(results[0].links?.[0].attributes?.['link.type'], 'producer');
-            assert.strictEqual(results[0].links?.[1].traceId, 'trace-upstream-2');
-            assert.strictEqual(results[0].links?.[1].spanId, 'span-upstream-2');
-            assert.strictEqual(results[0].links?.[1].attributes, undefined);
-            // Second span: single link with attributes
-            assert.strictEqual(results[1].links?.length, 1);
-            assert.strictEqual(results[1].links?.[0].traceId, 'trace-parent');
-            assert.strictEqual(results[1].links?.[0].attributes?.['link.reason'], 'causal');
-            // Third span: no links
-            assert.strictEqual(results[2].links, undefined);
-        });
-        it('should filter out invalid span links with missing context', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'mixed-links',
-                    startTime: [1700000000, 0],
-                    links: [
-                        {
-                            context: { traceId: 'valid-trace', spanId: 'valid-span' },
-                        },
-                        {
-                            context: { traceId: 'missing-span-id' },
-                        },
-                        {
-                            context: { spanId: 'missing-trace-id' },
-                        },
-                        {
-                            // No context at all
-                            attributes: { 'orphan': true },
-                        },
-                    ],
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            // Only the valid link should be included
-            assert.strictEqual(results[0].links?.length, 1);
-            assert.strictEqual(results[0].links?.[0].traceId, 'valid-trace');
-            assert.strictEqual(results[0].links?.[0].spanId, 'valid-span');
-        });
-        it('should set links to undefined when all links are invalid', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'all-invalid-links',
-                    startTime: [1700000000, 0],
-                    links: [
-                        { context: { traceId: 'missing-span' } },
-                        { context: { spanId: 'missing-trace' } },
-                    ],
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].links, undefined);
-        });
-        it('should return empty array when no files found', async () => {
-            // No files created - tempDir is empty
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 0);
-        });
-        it('should filter spans by attributeFilter with string value', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'hook:session-start',
-                    startTime: [1700000000, 0],
-                    attributes: { 'hook.name': 'session-start', 'hook.type': 'session' },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'hook:mcp-pre-tool',
-                    startTime: [1700000000, 0],
-                    attributes: { 'hook.name': 'mcp-pre-tool', 'mcp.server': 'signoz' },
-                },
-                {
-                    traceId: 'trace3',
-                    spanId: 'span3',
-                    name: 'hook:post-tool',
-                    startTime: [1700000000, 0],
-                    attributes: { 'hook.name': 'post-tool', 'mcp.server': 'webresearch' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                attributeFilter: { 'hook.name': 'session-start' },
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should filter spans by attributeFilter with multiple attributes', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'mcp-call',
-                    startTime: [1700000000, 0],
-                    attributes: { 'mcp.server': 'signoz', 'mcp.success': true },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'mcp-call',
-                    startTime: [1700000000, 0],
-                    attributes: { 'mcp.server': 'signoz', 'mcp.success': false },
-                },
-                {
-                    traceId: 'trace3',
-                    spanId: 'span3',
-                    name: 'mcp-call',
-                    startTime: [1700000000, 0],
-                    attributes: { 'mcp.server': 'webresearch', 'mcp.success': true },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                attributeFilter: { 'mcp.server': 'signoz', 'mcp.success': true },
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should filter spans by attributeFilter with number value', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 200 },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 500 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                attributeFilter: { 'http.status_code': 200 },
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should filter spans by attributeFilter with boolean value', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'agent-call',
-                    startTime: [1700000000, 0],
-                    attributes: { 'agent.is_background': true },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'agent-call',
-                    startTime: [1700000000, 0],
-                    attributes: { 'agent.is_background': false },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                attributeFilter: { 'agent.is_background': false },
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace2');
-        });
-        it('should return empty array when attributeFilter matches nothing', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'op1',
-                    startTime: [1700000000, 0],
-                    attributes: { 'hook.name': 'session-start' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                attributeFilter: { 'hook.name': 'nonexistent' },
-            });
-            assert.strictEqual(results.length, 0);
-        });
-        it('should combine attributeFilter with other filters', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'hook:mcp-pre-tool',
-                    startTime: [1700000000, 0],
-                    endTime: [1700000000, 500000000], // 500ms
-                    attributes: { 'mcp.server': 'signoz' },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'hook:mcp-pre-tool',
-                    startTime: [1700000000, 0],
-                    endTime: [1700000002, 0], // 2000ms
-                    attributes: { 'mcp.server': 'signoz' },
-                },
-                {
-                    traceId: 'trace3',
-                    spanId: 'span3',
-                    name: 'hook:mcp-pre-tool',
-                    startTime: [1700000000, 0],
-                    endTime: [1700000000, 500000000], // 500ms
-                    attributes: { 'mcp.server': 'webresearch' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                spanName: 'mcp',
-                minDurationMs: 1000,
-                attributeFilter: { 'mcp.server': 'signoz' },
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace2');
-        });
-        it('should exclude spans matching excludeSpanName', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'http-request', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'db-query', startTime: [1700000000, 0] },
-                { traceId: 'trace3', spanId: 'span3', name: 'http-response', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ excludeSpanName: 'http' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'db-query');
-        });
-        it('should filter spans by spanNameRegex', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'hook:session-start', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'hook:session-end', startTime: [1700000000, 0] },
-                { traceId: 'trace3', spanId: 'span3', name: 'mcp-call', startTime: [1700000000, 0] },
-                { traceId: 'trace4', spanId: 'span4', name: 'hook:pre-tool', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            // Match spans starting with 'hook:session'
-            const results = await backend.queryTraces({ spanNameRegex: '^hook:session' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.some(s => s.name === 'hook:session-start'));
-            assert.ok(results.some(s => s.name === 'hook:session-end'));
-        });
-        it('should filter spans by spanNameRegex with complex pattern', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'api-v1-users-get', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'api-v2-users-get', startTime: [1700000000, 0] },
-                { traceId: 'trace3', spanId: 'span3', name: 'api-v1-orders-post', startTime: [1700000000, 0] },
-                { traceId: 'trace4', spanId: 'span4', name: 'internal-process', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            // Match spans with api-v[12]-.*-get pattern
-            const results = await backend.queryTraces({ spanNameRegex: 'api-v[12]-.*-get' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.some(s => s.name === 'api-v1-users-get'));
-            assert.ok(results.some(s => s.name === 'api-v2-users-get'));
-        });
-        it('should handle invalid spanNameRegex gracefully', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'test-span', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            // Invalid regex pattern - should be skipped (all spans returned)
-            const results = await backend.queryTraces({ spanNameRegex: '[invalid(' });
-            // Invalid regex is skipped, so all spans should be returned
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'test-span');
-        });
-        it('should combine spanNameRegex with spanName filter', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'hook:mcp-pre-tool', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'hook:mcp-post-tool', startTime: [1700000000, 0] },
-                { traceId: 'trace3', spanId: 'span3', name: 'hook:session-start', startTime: [1700000000, 0] },
-                { traceId: 'trace4', spanId: 'span4', name: 'mcp-call', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            // spanName filters first (substring), then regex narrows down
-            const results = await backend.queryTraces({
-                spanName: 'hook',
-                spanNameRegex: 'mcp',
-            });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.some(s => s.name === 'hook:mcp-pre-tool'));
-            assert.ok(results.some(s => s.name === 'hook:mcp-post-tool'));
-        });
-        it('should combine spanNameRegex with excludeSpanName', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'hook:mcp-pre-tool', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'hook:mcp-post-tool', startTime: [1700000000, 0] },
-                { traceId: 'trace3', spanId: 'span3', name: 'hook:session-start', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            // Regex matches all hook:mcp-*, exclude post-tool
-            const results = await backend.queryTraces({
-                spanNameRegex: '^hook:mcp-',
-                excludeSpanName: 'post-tool',
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'hook:mcp-pre-tool');
-        });
-        it('should filter spans by attributeExists - all must exist', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'op1',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.method': 'GET', 'http.status_code': 200 },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'op2',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.method': 'POST' }, // missing http.status_code
-                },
-                {
-                    traceId: 'trace3',
-                    spanId: 'span3',
-                    name: 'op3',
-                    startTime: [1700000000, 0],
-                    attributes: { 'db.system': 'postgres' }, // missing both
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                attributeExists: ['http.method', 'http.status_code'],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should filter spans by attributeNotExists - exclude if any exist', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'op1',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.method': 'GET', 'error.message': 'timeout' },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'op2',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.method': 'POST' }, // no error attributes
-                },
-                {
-                    traceId: 'trace3',
-                    spanId: 'span3',
-                    name: 'op3',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.method': 'GET', 'error.type': 'network' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                attributeNotExists: ['error.message', 'error.type'],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace2');
-        });
-        it('should combine spanName with excludeSpanName', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'http-request-external', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'http-request-internal', startTime: [1700000000, 0] },
-                { traceId: 'trace3', spanId: 'span3', name: 'db-query', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                spanName: 'http',
-                excludeSpanName: 'internal',
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'http-request-external');
-        });
-        it('should combine attributeExists with attributeFilter', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'op1',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.method': 'GET', 'http.status_code': 200 },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'op2',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.method': 'POST', 'http.status_code': 500 },
-                },
-                {
-                    traceId: 'trace3',
-                    spanId: 'span3',
-                    name: 'op3',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.method': 'GET' }, // missing status_code
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                attributeFilter: { 'http.method': 'GET' },
-                attributeExists: ['http.status_code'],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should filter spans by numericFilter with gt operator', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 200 },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 500 },
-                },
-                {
-                    traceId: 'trace3',
-                    spanId: 'span3',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 300 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                numericFilter: [{ attribute: 'http.status_code', operator: 'gt', value: 299 }],
-            });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.some(s => s.traceId === 'trace2'));
-            assert.ok(results.some(s => s.traceId === 'trace3'));
-        });
-        it('should filter spans by numericFilter with gte operator', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 200 },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 300 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                numericFilter: [{ attribute: 'http.status_code', operator: 'gte', value: 300 }],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace2');
-        });
-        it('should filter spans by numericFilter with lt operator', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 200 },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 500 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                numericFilter: [{ attribute: 'http.status_code', operator: 'lt', value: 300 }],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should filter spans by numericFilter with lte operator', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 200 },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 300 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                numericFilter: [{ attribute: 'http.status_code', operator: 'lte', value: 200 }],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should filter spans by numericFilter with eq operator', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 200 },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 500 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                numericFilter: [{ attribute: 'http.status_code', operator: 'eq', value: 200 }],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should filter spans by multiple numericFilter conditions (AND logic)', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 200, 'http.response_size': 1000 },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 200, 'http.response_size': 5000 },
-                },
-                {
-                    traceId: 'trace3',
-                    spanId: 'span3',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 500, 'http.response_size': 100 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                numericFilter: [
-                    { attribute: 'http.status_code', operator: 'lt', value: 300 },
-                    { attribute: 'http.response_size', operator: 'gt', value: 2000 },
-                ],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace2');
-        });
-        it('should skip spans when numericFilter attribute is missing', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 200 },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'other.attr': 'value' }, // missing http.status_code
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                numericFilter: [{ attribute: 'http.status_code', operator: 'gte', value: 100 }],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should skip spans when numericFilter attribute is not a number', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 200 },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': '200' }, // string, not number
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                numericFilter: [{ attribute: 'http.status_code', operator: 'eq', value: 200 }],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should combine numericFilter with other filters', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 500, 'http.method': 'GET' },
-                },
-                {
-                    traceId: 'trace2',
-                    spanId: 'span2',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 500, 'http.method': 'POST' },
-                },
-                {
-                    traceId: 'trace3',
-                    spanId: 'span3',
-                    name: 'http-request',
-                    startTime: [1700000000, 0],
-                    attributes: { 'http.status_code': 200, 'http.method': 'GET' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                attributeFilter: { 'http.method': 'GET' },
-                numericFilter: [{ attribute: 'http.status_code', operator: 'gte', value: 400 }],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should complete queries with timing (timing is logged for slow queries)', async () => {
-            // This test verifies that query timing is active and doesn't break normal queries
-            // Timing warnings are logged for queries > 500ms
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'op2', startTime: [1700000001, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            // Query should complete successfully with timing active
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 2);
-        });
-    });
-    describe('queryLogs', () => {
-        it('should read and normalize log records from JSONL files', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00.000Z',
-                    severityText: 'ERROR',
-                    body: 'Connection failed',
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    resource: { serviceName: 'api-service' },
-                    attributes: { 'error.type': 'timeout' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].severity, 'ERROR');
-            assert.strictEqual(results[0].body, 'Connection failed');
-            assert.strictEqual(results[0].attributes?.['service.name'], 'api-service');
-            assert.strictEqual(results[0].attributes?.['error.type'], 'timeout');
-        });
-        it('should handle timestamp as ISO string', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00.123Z',
-                    body: 'Test log',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({});
-            assert.strictEqual(results[0].timestamp, '2026-01-28T10:00:00.123Z');
-        });
-        it('should convert timestamp from [seconds, nanoseconds] array', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: [1700000000, 123456789], // seconds + nanoseconds
-                    body: 'Test log',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({});
-            // Verify it's a valid ISO string
-            assert.match(results[0].timestamp, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
-        });
-        it('should filter logs by severity (case-insensitive)', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: '2026-01-28T10:00:00Z', severityText: 'ERROR', body: 'Error 1' },
-                { timestamp: '2026-01-28T10:01:00Z', severity: 'WARN', body: 'Warning 1' },
-                { timestamp: '2026-01-28T10:02:00Z', severity: 'error', body: 'Error 2' },
-                { timestamp: '2026-01-28T10:03:00Z', severity: 'INFO', body: 'Info 1' },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({ severity: 'ERROR' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.every(l => l.severity.toUpperCase() === 'ERROR'));
-        });
-        it('should filter logs by traceId', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: '2026-01-28T10:00:00Z', body: 'Log 1', traceId: 'trace1' },
-                { timestamp: '2026-01-28T10:01:00Z', body: 'Log 2', traceId: 'trace2' },
-                { timestamp: '2026-01-28T10:02:00Z', body: 'Log 3', traceId: 'trace1' },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({ traceId: 'trace1' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.every(l => l.traceId === 'trace1'));
-        });
-        it('should filter logs by search text (case-insensitive substring)', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: '2026-01-28T10:00:00Z', body: 'Connection timeout' },
-                { timestamp: '2026-01-28T10:01:00Z', body: 'Database query failed' },
-                { timestamp: '2026-01-28T10:02:00Z', body: 'Connection reset by peer' },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({ search: 'CONNECTION' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.every(l => l.body.toLowerCase().includes('connection')));
-        });
-        it('should use severityText if available, fallback to severity', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: '2026-01-28T10:00:00Z', body: 'Log 1', severityText: 'CUSTOM' },
-                { timestamp: '2026-01-28T10:01:00Z', body: 'Log 2', severity: 'WARN' },
-                { timestamp: '2026-01-28T10:02:00Z', body: 'Log 3' }, // no severity
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({});
-            assert.strictEqual(results[0].severity, 'CUSTOM');
-            assert.strictEqual(results[1].severity, 'WARN');
-            assert.strictEqual(results[2].severity, 'INFO'); // default
-        });
-        it('should extract instrumentationScope from logs', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: 'HTTP request received',
-                    instrumentationScope: {
-                        name: '@opentelemetry/instrumentation-http',
-                        version: '0.48.0',
-                        schemaUrl: 'https://opentelemetry.io/schemas/1.21.0',
-                    },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    body: 'Custom log from hooks',
-                    instrumentationScope: {
-                        name: 'custom-hooks',
-                    },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    body: 'Log without scope',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({});
-            assert.strictEqual(results.length, 3);
-            // First log: full scope
-            assert.strictEqual(results[0].instrumentationScope?.name, '@opentelemetry/instrumentation-http');
-            assert.strictEqual(results[0].instrumentationScope?.version, '0.48.0');
-            assert.strictEqual(results[0].instrumentationScope?.schemaUrl, 'https://opentelemetry.io/schemas/1.21.0');
-            // Second log: name only
-            assert.strictEqual(results[1].instrumentationScope?.name, 'custom-hooks');
-            assert.strictEqual(results[1].instrumentationScope?.version, undefined);
-            // Third log: no scope
-            assert.strictEqual(results[2].instrumentationScope, undefined);
-        });
-        it('should apply limit and offset to log results', async () => {
-            const today = getTestDate();
-            const mockLogs = Array.from({ length: 200 }, (_, i) => ({
-                timestamp: new Date(Date.now() + i * 1000).toISOString(),
-                body: `Log ${i}`,
-            }));
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({ limit: 50, offset: 75 });
-            assert.strictEqual(results.length, 50);
-            assert.strictEqual(results[0].body, 'Log 75');
-        });
-        it('should handle empty body field', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: '2026-01-28T10:00:00Z', body: 'Normal log' },
-                { timestamp: '2026-01-28T10:01:00Z' }, // missing body
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({});
-            assert.strictEqual(results.length, 2);
-            assert.strictEqual(results[1].body, '');
-        });
-        it('should set severityNumber based on severity text', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: '2026-01-28T10:00:00Z', severityText: 'TRACE', body: 'Trace log' },
-                { timestamp: '2026-01-28T10:01:00Z', severityText: 'DEBUG', body: 'Debug log' },
-                { timestamp: '2026-01-28T10:02:00Z', severityText: 'INFO', body: 'Info log' },
-                { timestamp: '2026-01-28T10:03:00Z', severityText: 'WARN', body: 'Warn log' },
-                { timestamp: '2026-01-28T10:04:00Z', severityText: 'ERROR', body: 'Error log' },
-                { timestamp: '2026-01-28T10:05:00Z', severityText: 'FATAL', body: 'Fatal log' },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({});
-            assert.strictEqual(results.length, 6);
-            assert.strictEqual(results[0].severityNumber, 1); // TRACE
-            assert.strictEqual(results[1].severityNumber, 5); // DEBUG
-            assert.strictEqual(results[2].severityNumber, 9); // INFO
-            assert.strictEqual(results[3].severityNumber, 13); // WARN
-            assert.strictEqual(results[4].severityNumber, 17); // ERROR
-            assert.strictEqual(results[5].severityNumber, 21); // FATAL
-        });
-        it('should handle lowercase severity when setting severityNumber', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: '2026-01-28T10:00:00Z', severity: 'error', body: 'Lowercase error' },
-                { timestamp: '2026-01-28T10:01:00Z', severity: 'warn', body: 'Lowercase warn' },
-                { timestamp: '2026-01-28T10:02:00Z', severity: 'info', body: 'Lowercase info' },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({});
-            assert.strictEqual(results.length, 3);
-            assert.strictEqual(results[0].severityNumber, 17); // error -> ERROR -> 17
-            assert.strictEqual(results[1].severityNumber, 13); // warn -> WARN -> 13
-            assert.strictEqual(results[2].severityNumber, 9); // info -> INFO -> 9
-        });
-        it('should set severityNumber to undefined for unknown severity levels', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: '2026-01-28T10:00:00Z', severityText: 'CUSTOM', body: 'Custom severity' },
-                { timestamp: '2026-01-28T10:01:00Z', severityText: 'VERBOSE', body: 'Verbose severity' },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({});
-            assert.strictEqual(results.length, 2);
-            assert.strictEqual(results[0].severityNumber, undefined);
-            assert.strictEqual(results[1].severityNumber, undefined);
-        });
-        it('should set severityNumber to 9 (INFO) when severity defaults', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: '2026-01-28T10:00:00Z', body: 'No severity specified' },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].severity, 'INFO');
-            assert.strictEqual(results[0].severityNumber, 9);
-        });
-        it('should exclude logs matching excludeSearch', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: '2026-01-28T10:00:00Z', body: 'Connection failed' },
-                { timestamp: '2026-01-28T10:01:00Z', body: 'Request successful' },
-                { timestamp: '2026-01-28T10:02:00Z', body: 'Connection timeout' },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({ excludeSearch: 'connection' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].body, 'Request successful');
-        });
-        it('should combine search with excludeSearch', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: '2026-01-28T10:00:00Z', body: 'User login successful' },
-                { timestamp: '2026-01-28T10:01:00Z', body: 'User login failed' },
-                { timestamp: '2026-01-28T10:02:00Z', body: 'System startup' },
-                { timestamp: '2026-01-28T10:03:00Z', body: 'User logout' },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                search: 'user',
-                excludeSearch: 'failed',
-            });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.some(l => l.body === 'User login successful'));
-            assert.ok(results.some(l => l.body === 'User logout'));
-        });
-        it('should filter logs by attributeExists - all must exist', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: 'Log 1',
-                    attributes: { 'request.id': 'abc', 'user.id': '123' },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    body: 'Log 2',
-                    attributes: { 'request.id': 'def' }, // missing user.id
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    body: 'Log 3',
-                    attributes: { 'other.attr': 'value' }, // missing both
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                attributeExists: ['request.id', 'user.id'],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].body, 'Log 1');
-        });
-        it('should filter logs by attributeNotExists - exclude if any exist', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: 'Log with error',
-                    attributes: { 'request.id': 'abc', 'error.message': 'timeout' },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    body: 'Clean log',
-                    attributes: { 'request.id': 'def' },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    body: 'Log with exception',
-                    attributes: { 'request.id': 'ghi', 'exception.type': 'NullPointer' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                attributeNotExists: ['error.message', 'exception.type'],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].body, 'Clean log');
-        });
-        it('should combine search with attribute filters', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: 'API request completed',
-                    attributes: { 'request.id': 'abc', 'http.status_code': 200 },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    body: 'API request failed',
-                    attributes: { 'request.id': 'def' }, // missing status_code
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    body: 'Database query completed',
-                    attributes: { 'request.id': 'ghi', 'http.status_code': 200 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                search: 'API',
-                attributeExists: ['http.status_code'],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].body, 'API request completed');
-        });
-        it('should filter logs by numericFilter with gt operator', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: 'Request completed',
-                    attributes: { 'http.status_code': 200 },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    body: 'Request failed',
-                    attributes: { 'http.status_code': 500 },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    body: 'Request redirected',
-                    attributes: { 'http.status_code': 302 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                numericFilter: [{ attribute: 'http.status_code', operator: 'gt', value: 299 }],
-            });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.some(l => l.body === 'Request failed'));
-            assert.ok(results.some(l => l.body === 'Request redirected'));
-        });
-        it('should filter logs by numericFilter with lt operator', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: 'Small response',
-                    attributes: { 'response.size': 100 },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    body: 'Large response',
-                    attributes: { 'response.size': 5000 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                numericFilter: [{ attribute: 'response.size', operator: 'lt', value: 1000 }],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].body, 'Small response');
-        });
-        it('should filter logs by multiple numericFilter conditions', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: 'Fast small response',
-                    attributes: { 'response.size': 100, 'response.time_ms': 50 },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    body: 'Slow large response',
-                    attributes: { 'response.size': 5000, 'response.time_ms': 2000 },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    body: 'Fast large response',
-                    attributes: { 'response.size': 5000, 'response.time_ms': 100 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                numericFilter: [
-                    { attribute: 'response.size', operator: 'gte', value: 1000 },
-                    { attribute: 'response.time_ms', operator: 'lte', value: 500 },
-                ],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].body, 'Fast large response');
-        });
-        it('should skip logs when numericFilter attribute is missing or not a number', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: 'Log with numeric',
-                    attributes: { 'count': 100 },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    body: 'Log with string',
-                    attributes: { 'count': 'one hundred' },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    body: 'Log without count',
-                    attributes: { 'other': 'value' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                numericFilter: [{ attribute: 'count', operator: 'gte', value: 50 }],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].body, 'Log with numeric');
-        });
-        it('should combine numericFilter with search and severity', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: 'API Error: rate limit',
-                    severity: 'ERROR',
-                    attributes: { 'http.status_code': 429, 'retry_count': 3 },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    body: 'API Error: server error',
-                    severity: 'ERROR',
-                    attributes: { 'http.status_code': 500, 'retry_count': 1 },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    body: 'API Error: timeout',
-                    severity: 'WARN',
-                    attributes: { 'http.status_code': 408, 'retry_count': 5 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                search: 'API Error',
-                severity: 'ERROR',
-                numericFilter: [{ attribute: 'retry_count', operator: 'gt', value: 2 }],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].body, 'API Error: rate limit');
-        });
-        it('should extract fields from JSON log body using dot notation', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: '{"user":{"id":"user123","name":"Alice"},"request":{"method":"POST","path":"/api/v1/users"}}',
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    body: '{"user":{"id":"user456"},"request":{"method":"GET"}}',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                extractFields: ['user.id', 'request.method'],
-            });
-            assert.strictEqual(results.length, 2);
-            assert.deepStrictEqual(results[0].extractedFields, {
-                'user.id': 'user123',
-                'request.method': 'POST',
-            });
-            assert.deepStrictEqual(results[1].extractedFields, {
-                'user.id': 'user456',
-                'request.method': 'GET',
-            });
-        });
-        it('should handle missing fields gracefully during extraction', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: '{"user":{"id":"user123"},"status":"ok"}',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                extractFields: ['user.id', 'user.name', 'nonexistent.path'],
-            });
-            assert.strictEqual(results.length, 1);
-            // Only user.id exists, user.name and nonexistent.path are undefined
-            assert.deepStrictEqual(results[0].extractedFields, {
-                'user.id': 'user123',
-            });
-        });
-        it('should not extract fields from non-JSON log bodies', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: 'Plain text log message',
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    body: '[2026-01-28] INFO: Starting service',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                extractFields: ['user.id', 'message'],
-            });
-            assert.strictEqual(results.length, 2);
-            assert.strictEqual(results[0].extractedFields, undefined);
-            assert.strictEqual(results[1].extractedFields, undefined);
-        });
-        it('should not extract fields when extractFields is empty', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: '{"user":{"id":"user123"}}',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                extractFields: [],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].extractedFields, undefined);
-        });
-        it('should extract deeply nested fields', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: '{"response":{"data":{"items":[1,2,3],"meta":{"count":3}}}}',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                extractFields: ['response.data.meta.count', 'response.data.items'],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.deepStrictEqual(results[0].extractedFields, {
-                'response.data.meta.count': 3,
-                'response.data.items': [1, 2, 3],
-            });
-        });
-        it('should handle invalid JSON gracefully during extraction', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: '{invalid json',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                extractFields: ['user.id'],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].extractedFields, undefined);
-        });
-        it('should return undefined extractedFields when no fields match', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    body: '{"foo":"bar"}',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const results = await backend.queryLogs({
-                extractFields: ['nonexistent.field', 'another.missing'],
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].extractedFields, undefined);
-        });
-    });
-    describe('queryMetrics', () => {
-        it('should read and normalize metric data points from JSONL files', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'http.requests.total',
-                    value: 100,
-                    type: 'counter',
-                    unit: 'requests',
-                    resource: { serviceName: 'api-gateway' },
-                    attributes: { 'http.method': 'GET', 'http.status_code': 200 },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'http.requests.total');
-            assert.strictEqual(results[0].value, 100);
-            assert.strictEqual(results[0].unit, 'requests');
-            assert.strictEqual(results[0].attributes?.['service.name'], 'api-gateway');
-            assert.strictEqual(results[0].attributes?.['http.method'], 'GET');
-        });
-        it('should filter metrics by name substring', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'http.requests.total', value: 100, type: 'counter' },
-                { timestamp: '2026-01-28T10:01:00Z', name: 'http.request.duration', value: 150, type: 'histogram' },
-                { timestamp: '2026-01-28T10:02:00Z', name: 'memory.usage', value: 512, type: 'gauge' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ metricName: 'http' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.every(m => m.name.includes('http')));
-        });
-        it('should apply limit and offset to metric results', async () => {
-            const today = getTestDate();
-            const mockMetrics = Array.from({ length: 150 }, (_, i) => ({
-                timestamp: new Date(Date.now() + i * 1000).toISOString(),
-                name: `metric.${i}`,
-                value: i * 10,
-                type: 'gauge',
-            }));
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ limit: 50, offset: 30 });
-            assert.strictEqual(results.length, 50);
-            assert.strictEqual(results[0].name, 'metric.30');
-        });
-        it('should aggregate metrics with sum function', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'requests', value: 100, type: 'counter' },
-                { timestamp: '2026-01-28T10:01:00Z', name: 'requests', value: 150, type: 'counter' },
-                { timestamp: '2026-01-28T10:02:00Z', name: 'requests', value: 200, type: 'counter' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'sum' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 450);
-        });
-        it('should aggregate metrics with avg function', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'latency', value: 100, type: 'histogram' },
-                { timestamp: '2026-01-28T10:01:00Z', name: 'latency', value: 200, type: 'histogram' },
-                { timestamp: '2026-01-28T10:02:00Z', name: 'latency', value: 300, type: 'histogram' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'avg' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 200);
-        });
-        it('should aggregate metrics with min function', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'response_time', value: 150, type: 'gauge' },
-                { timestamp: '2026-01-28T10:01:00Z', name: 'response_time', value: 50, type: 'gauge' },
-                { timestamp: '2026-01-28T10:02:00Z', name: 'response_time', value: 200, type: 'gauge' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'min' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 50);
-        });
-        it('should aggregate metrics with max function', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'memory', value: 512, type: 'gauge' },
-                { timestamp: '2026-01-28T10:01:00Z', name: 'memory', value: 256, type: 'gauge' },
-                { timestamp: '2026-01-28T10:02:00Z', name: 'memory', value: 1024, type: 'gauge' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'max' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 1024);
-        });
-        it('should aggregate metrics with count function', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'events', value: 10, type: 'counter' },
-                { timestamp: '2026-01-28T10:01:00Z', name: 'events', value: 20, type: 'counter' },
-                { timestamp: '2026-01-28T10:02:00Z', name: 'events', value: 30, type: 'counter' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'count' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 3);
-        });
-        it('should aggregate metrics with p50 (median) function', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'latency', value: 10, type: 'histogram' },
-                { timestamp: '2026-01-28T10:01:00Z', name: 'latency', value: 20, type: 'histogram' },
-                { timestamp: '2026-01-28T10:02:00Z', name: 'latency', value: 30, type: 'histogram' },
-                { timestamp: '2026-01-28T10:03:00Z', name: 'latency', value: 40, type: 'histogram' },
-                { timestamp: '2026-01-28T10:04:00Z', name: 'latency', value: 50, type: 'histogram' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'p50' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 30); // median of [10, 20, 30, 40, 50]
-        });
-        it('should aggregate metrics with p95 function', async () => {
-            const today = getTestDate();
-            // Create 100 data points for a more realistic p95 calculation
-            const mockMetrics = Array.from({ length: 100 }, (_, i) => ({
-                timestamp: `2026-01-28T10:${String(Math.floor(i / 60)).padStart(2, '0')}:${String(i % 60).padStart(2, '0')}Z`,
-                name: 'response_time',
-                value: i + 1, // values 1-100
-                type: 'histogram',
-            }));
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'p95' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 95); // 95th percentile of 1-100
-        });
-        it('should aggregate metrics with p99 function', async () => {
-            const today = getTestDate();
-            // Create 100 data points for a more realistic p99 calculation
-            const mockMetrics = Array.from({ length: 100 }, (_, i) => ({
-                timestamp: `2026-01-28T10:${String(Math.floor(i / 60)).padStart(2, '0')}:${String(i % 60).padStart(2, '0')}Z`,
-                name: 'response_time',
-                value: i + 1, // values 1-100
-                type: 'histogram',
-            }));
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'p99' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 99); // 99th percentile of 1-100
-        });
-        it('should handle p50 with even number of values', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'latency', value: 10, type: 'histogram' },
-                { timestamp: '2026-01-28T10:01:00Z', name: 'latency', value: 20, type: 'histogram' },
-                { timestamp: '2026-01-28T10:02:00Z', name: 'latency', value: 30, type: 'histogram' },
-                { timestamp: '2026-01-28T10:03:00Z', name: 'latency', value: 40, type: 'histogram' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'p50' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 20); // ceil(0.5 * 4) - 1 = 1, sorted[1] = 20
-        });
-        it('should handle percentile with single value', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'latency', value: 42, type: 'histogram' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'p95' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 42); // single value is the only percentile
-        });
-        it('should calculate percentiles with groupBy', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'latency', value: 10, type: 'histogram', attributes: { endpoint: '/api/users' } },
-                { timestamp: '2026-01-28T10:01:00Z', name: 'latency', value: 20, type: 'histogram', attributes: { endpoint: '/api/users' } },
-                { timestamp: '2026-01-28T10:02:00Z', name: 'latency', value: 30, type: 'histogram', attributes: { endpoint: '/api/users' } },
-                { timestamp: '2026-01-28T10:03:00Z', name: 'latency', value: 100, type: 'histogram', attributes: { endpoint: '/api/orders' } },
-                { timestamp: '2026-01-28T10:04:00Z', name: 'latency', value: 200, type: 'histogram', attributes: { endpoint: '/api/orders' } },
-                { timestamp: '2026-01-28T10:05:00Z', name: 'latency', value: 300, type: 'histogram', attributes: { endpoint: '/api/orders' } },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'p50', groupBy: ['endpoint'] });
-            assert.strictEqual(results.length, 2);
-            const usersMetric = results.find(m => m.attributes?.endpoint === '/api/users');
-            const ordersMetric = results.find(m => m.attributes?.endpoint === '/api/orders');
-            assert.strictEqual(usersMetric?.value, 20); // median of [10, 20, 30]
-            assert.strictEqual(ordersMetric?.value, 200); // median of [100, 200, 300]
-        });
-        it('should aggregate metrics grouped by attributes', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'http.requests',
-                    value: 100,
-                    type: 'counter',
-                    attributes: { method: 'GET' },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'http.requests',
-                    value: 50,
-                    type: 'counter',
-                    attributes: { method: 'POST' },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    name: 'http.requests',
-                    value: 200,
-                    type: 'counter',
-                    attributes: { method: 'GET' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'sum', groupBy: ['method'] });
-            assert.strictEqual(results.length, 2);
-            const getMetric = results.find(m => m.attributes?.method === 'GET');
-            const postMetric = results.find(m => m.attributes?.method === 'POST');
-            assert.strictEqual(getMetric?.value, 300);
-            assert.strictEqual(postMetric?.value, 50);
-        });
-        it('should return empty array when no metrics found', async () => {
-            // No files created
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 0);
-        });
-        it('should aggregate metrics by time bucket with 1m buckets', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                // First minute bucket: 10:00:00 - 10:00:59
-                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 10, type: 'counter' },
-                { timestamp: `${today}T10:00:30Z`, name: 'requests', value: 20, type: 'counter' },
-                { timestamp: `${today}T10:00:45Z`, name: 'requests', value: 30, type: 'counter' },
-                // Second minute bucket: 10:01:00 - 10:01:59
-                { timestamp: `${today}T10:01:00Z`, name: 'requests', value: 100, type: 'counter' },
-                { timestamp: `${today}T10:01:30Z`, name: 'requests', value: 200, type: 'counter' },
-                // Third minute bucket: 10:02:00 - 10:02:59
-                { timestamp: `${today}T10:02:15Z`, name: 'requests', value: 50, type: 'counter' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'sum', timeBucket: '1m' });
-            assert.strictEqual(results.length, 3);
-            // Results should be sorted by timestamp
-            assert.strictEqual(results[0].value, 60); // 10 + 20 + 30
-            assert.strictEqual(results[1].value, 300); // 100 + 200
-            assert.strictEqual(results[2].value, 50); // 50
-            // Timestamps should be floored to bucket boundaries
-            assert.strictEqual(results[0].timestamp, `${today}T10:00:00.000Z`);
-            assert.strictEqual(results[1].timestamp, `${today}T10:01:00.000Z`);
-            assert.strictEqual(results[2].timestamp, `${today}T10:02:00.000Z`);
-        });
-        it('should aggregate metrics by time bucket with 5m buckets', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                // First 5-minute bucket: 10:00:00 - 10:04:59
-                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 10, type: 'counter' },
-                { timestamp: `${today}T10:02:00Z`, name: 'requests', value: 20, type: 'counter' },
-                { timestamp: `${today}T10:04:00Z`, name: 'requests', value: 30, type: 'counter' },
-                // Second 5-minute bucket: 10:05:00 - 10:09:59
-                { timestamp: `${today}T10:05:00Z`, name: 'requests', value: 100, type: 'counter' },
-                { timestamp: `${today}T10:08:00Z`, name: 'requests', value: 200, type: 'counter' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'sum', timeBucket: '5m' });
-            assert.strictEqual(results.length, 2);
-            assert.strictEqual(results[0].value, 60); // 10 + 20 + 30
-            assert.strictEqual(results[1].value, 300); // 100 + 200
-        });
-        it('should aggregate metrics by time bucket with 1h buckets', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                // First hour bucket: 10:00:00 - 10:59:59
-                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 10, type: 'counter' },
-                { timestamp: `${today}T10:30:00Z`, name: 'requests', value: 20, type: 'counter' },
-                // Second hour bucket: 11:00:00 - 11:59:59
-                { timestamp: `${today}T11:00:00Z`, name: 'requests', value: 100, type: 'counter' },
-                { timestamp: `${today}T11:45:00Z`, name: 'requests', value: 200, type: 'counter' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'sum', timeBucket: '1h' });
-            assert.strictEqual(results.length, 2);
-            assert.strictEqual(results[0].value, 30); // 10 + 20
-            assert.strictEqual(results[1].value, 300); // 100 + 200
-        });
-        it('should aggregate metrics by time bucket with 1d buckets', async () => {
-            // Create metrics files for two days
-            writeJsonlFile(path.join(tempDir, 'metrics-2026-01-28.jsonl'), [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'requests', value: 100, type: 'counter' },
-                { timestamp: '2026-01-28T20:00:00Z', name: 'requests', value: 200, type: 'counter' },
-            ]);
-            writeJsonlFile(path.join(tempDir, 'metrics-2026-01-29.jsonl'), [
-                { timestamp: '2026-01-29T08:00:00Z', name: 'requests', value: 300, type: 'counter' },
-                { timestamp: '2026-01-29T16:00:00Z', name: 'requests', value: 400, type: 'counter' },
-            ]);
-            const results = await backend.queryMetrics({
-                aggregation: 'sum',
-                timeBucket: '1d',
-                startDate: '2026-01-28',
-                endDate: '2026-01-29',
-            });
-            assert.strictEqual(results.length, 2);
-            assert.strictEqual(results[0].value, 300); // 100 + 200
-            assert.strictEqual(results[1].value, 700); // 300 + 400
-        });
-        it('should combine time bucket with groupBy', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                // First minute, method=GET
-                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 10, type: 'counter', attributes: { method: 'GET' } },
-                { timestamp: `${today}T10:00:30Z`, name: 'requests', value: 20, type: 'counter', attributes: { method: 'GET' } },
-                // First minute, method=POST
-                { timestamp: `${today}T10:00:15Z`, name: 'requests', value: 5, type: 'counter', attributes: { method: 'POST' } },
-                // Second minute, method=GET
-                { timestamp: `${today}T10:01:00Z`, name: 'requests', value: 100, type: 'counter', attributes: { method: 'GET' } },
-                // Second minute, method=POST
-                { timestamp: `${today}T10:01:30Z`, name: 'requests', value: 50, type: 'counter', attributes: { method: 'POST' } },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({
-                aggregation: 'sum',
-                timeBucket: '1m',
-                groupBy: ['method'],
-            });
-            assert.strictEqual(results.length, 4);
-            // First bucket GET
-            const bucket1GET = results.find(m => m.timestamp === `${today}T10:00:00.000Z` && m.attributes?.method === 'GET');
-            assert.strictEqual(bucket1GET?.value, 30); // 10 + 20
-            // First bucket POST
-            const bucket1POST = results.find(m => m.timestamp === `${today}T10:00:00.000Z` && m.attributes?.method === 'POST');
-            assert.strictEqual(bucket1POST?.value, 5);
-            // Second bucket GET
-            const bucket2GET = results.find(m => m.timestamp === `${today}T10:01:00.000Z` && m.attributes?.method === 'GET');
-            assert.strictEqual(bucket2GET?.value, 100);
-            // Second bucket POST
-            const bucket2POST = results.find(m => m.timestamp === `${today}T10:01:00.000Z` && m.attributes?.method === 'POST');
-            assert.strictEqual(bucket2POST?.value, 50);
-        });
-        it('should use avg aggregation with time buckets', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                // First minute bucket
-                { timestamp: `${today}T10:00:00Z`, name: 'latency', value: 100, type: 'histogram' },
-                { timestamp: `${today}T10:00:30Z`, name: 'latency', value: 200, type: 'histogram' },
-                { timestamp: `${today}T10:00:45Z`, name: 'latency', value: 300, type: 'histogram' },
-                // Second minute bucket
-                { timestamp: `${today}T10:01:00Z`, name: 'latency', value: 500, type: 'histogram' },
-                { timestamp: `${today}T10:01:30Z`, name: 'latency', value: 700, type: 'histogram' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'avg', timeBucket: '1m' });
-            assert.strictEqual(results.length, 2);
-            assert.strictEqual(results[0].value, 200); // (100 + 200 + 300) / 3
-            assert.strictEqual(results[1].value, 600); // (500 + 700) / 2
-        });
-        it('should ignore invalid time bucket format', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 10, type: 'counter' },
-                { timestamp: `${today}T10:00:30Z`, name: 'requests', value: 20, type: 'counter' },
-                { timestamp: `${today}T10:01:00Z`, name: 'requests', value: 30, type: 'counter' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            // Invalid format - should be ignored and aggregate all together
-            const results = await backend.queryMetrics({ aggregation: 'sum', timeBucket: 'invalid' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 60); // All grouped together
-        });
-        it('should calculate rate of change per second', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 100, type: 'counter' },
-                { timestamp: `${today}T10:00:30Z`, name: 'requests', value: 200, type: 'counter' },
-                { timestamp: `${today}T10:01:00Z`, name: 'requests', value: 400, type: 'counter' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'rate' });
-            assert.strictEqual(results.length, 1);
-            // Rate = (400 - 100) / 60 seconds = 5 per second
-            assert.strictEqual(results[0].value, 5);
-        });
-        it('should calculate rate with timeBucket', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                // First minute bucket: 10:00:00 - 10:00:59
-                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 0, type: 'counter' },
-                { timestamp: `${today}T10:00:30Z`, name: 'requests', value: 60, type: 'counter' },
-                // Second minute bucket: 10:01:00 - 10:01:59
-                { timestamp: `${today}T10:01:00Z`, name: 'requests', value: 100, type: 'counter' },
-                { timestamp: `${today}T10:01:30Z`, name: 'requests', value: 250, type: 'counter' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'rate', timeBucket: '1m' });
-            assert.strictEqual(results.length, 2);
-            // First bucket: (60 - 0) / 30 seconds = 2 per second
-            assert.strictEqual(results[0].value, 2);
-            // Second bucket: (250 - 100) / 30 seconds = 5 per second
-            assert.strictEqual(results[1].value, 5);
-        });
-        it('should return rate of 0 for single data point', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 100, type: 'counter' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'rate' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].value, 0);
-        });
-        it('should return rate of 0 when all timestamps are the same', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 100, type: 'counter' },
-                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 200, type: 'counter' },
-                { timestamp: `${today}T10:00:00Z`, name: 'requests', value: 300, type: 'counter' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ aggregation: 'rate' });
-            assert.strictEqual(results.length, 1);
-            // Avoid division by zero - return 0 when duration is 0
-            assert.strictEqual(results[0].value, 0);
-        });
-        it('should read and normalize histogram metrics with bucket distribution', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'http.request.duration',
-                    value: 150, // typically the sum/count average or similar aggregate
-                    type: 'histogram',
-                    unit: 'ms',
-                    resource: { serviceName: 'api-gateway' },
-                    attributes: { 'http.method': 'GET' },
-                    histogram: {
-                        buckets: [
-                            { le: 50, count: 10 },
-                            { le: 100, count: 25 },
-                            { le: 250, count: 45 },
-                            { le: 500, count: 48 },
-                            { le: Infinity, count: 50 },
-                        ],
-                        sum: 7500,
-                        count: 50,
-                    },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'http.request.duration');
-            assert.strictEqual(results[0].value, 150);
-            assert.strictEqual(results[0].unit, 'ms');
-            assert.strictEqual(results[0].attributes?.['service.name'], 'api-gateway');
-            assert.strictEqual(results[0].attributes?.['http.method'], 'GET');
-            // Verify histogram data is present
-            assert.ok(results[0].histogram, 'Histogram data should be present');
-            assert.strictEqual(results[0].histogram?.sum, 7500);
-            assert.strictEqual(results[0].histogram?.count, 50);
-            assert.strictEqual(results[0].histogram?.buckets.length, 5);
-            // Verify bucket boundaries and cumulative counts
-            assert.strictEqual(results[0].histogram?.buckets[0].le, 50);
-            assert.strictEqual(results[0].histogram?.buckets[0].count, 10);
-            assert.strictEqual(results[0].histogram?.buckets[1].le, 100);
-            assert.strictEqual(results[0].histogram?.buckets[1].count, 25);
-            assert.strictEqual(results[0].histogram?.buckets[2].le, 250);
-            assert.strictEqual(results[0].histogram?.buckets[2].count, 45);
-        });
-        it('should handle histogram metrics without histogram data (non-histogram type)', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'http.requests.total',
-                    value: 100,
-                    type: 'counter',
-                    unit: 'requests',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'http.requests.total');
-            assert.strictEqual(results[0].value, 100);
-            assert.strictEqual(results[0].histogram, undefined);
-        });
-        it('should handle mixed metric types including histograms', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'http.requests.total',
-                    value: 100,
-                    type: 'counter',
-                },
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'http.request.duration',
-                    value: 150,
-                    type: 'histogram',
-                    histogram: {
-                        buckets: [
-                            { le: 100, count: 20 },
-                            { le: 500, count: 80 },
-                            { le: Infinity, count: 100 },
-                        ],
-                        sum: 15000,
-                        count: 100,
-                    },
-                },
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'memory.usage',
-                    value: 512,
-                    type: 'gauge',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 3);
-            const counter = results.find(m => m.name === 'http.requests.total');
-            const histogram = results.find(m => m.name === 'http.request.duration');
-            const gauge = results.find(m => m.name === 'memory.usage');
-            assert.ok(counter, 'Counter metric should be present');
-            assert.strictEqual(counter?.histogram, undefined);
-            assert.ok(histogram, 'Histogram metric should be present');
-            assert.ok(histogram?.histogram, 'Histogram should have histogram data');
-            assert.strictEqual(histogram?.histogram?.count, 100);
-            assert.ok(gauge, 'Gauge metric should be present');
-            assert.strictEqual(gauge?.histogram, undefined);
-        });
-        it('should preserve histogram data when filtering by metric name', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'api.latency',
-                    value: 200,
-                    type: 'histogram',
-                    histogram: {
-                        buckets: [
-                            { le: 100, count: 5 },
-                            { le: 500, count: 15 },
-                            { le: 1000, count: 20 },
-                        ],
-                        sum: 4000,
-                        count: 20,
-                    },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'db.query.duration',
-                    value: 50,
-                    type: 'histogram',
-                    histogram: {
-                        buckets: [
-                            { le: 10, count: 30 },
-                            { le: 50, count: 80 },
-                            { le: 100, count: 100 },
-                        ],
-                        sum: 3500,
-                        count: 100,
-                    },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({ metricName: 'api.latency' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'api.latency');
-            assert.ok(results[0].histogram);
-            assert.strictEqual(results[0].histogram?.sum, 4000);
-            assert.strictEqual(results[0].histogram?.count, 20);
-            assert.strictEqual(results[0].histogram?.buckets.length, 3);
-        });
-        it('should ignore histogram field when metric type is not histogram', async () => {
-            const today = getTestDate();
-            // Edge case: a metric that has histogram field but type is not 'histogram'
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'malformed.metric',
-                    value: 100,
-                    type: 'gauge', // Not histogram type
-                    histogram: {
-                        // This should be ignored since type != 'histogram'
-                        buckets: [{ le: 100, count: 10 }],
-                        sum: 500,
-                        count: 10,
-                    },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'malformed.metric');
-            assert.strictEqual(results[0].value, 100);
-            // Histogram data should NOT be included since type is 'gauge', not 'histogram'
-            assert.strictEqual(results[0].histogram, undefined);
-        });
-        it('should normalize aggregationTemporality from numeric OTel values', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'http.requests.delta',
-                    value: 100,
-                    type: 'counter',
-                    aggregationTemporality: 1, // DELTA
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'http.requests.cumulative',
-                    value: 500,
-                    type: 'counter',
-                    aggregationTemporality: 2, // CUMULATIVE
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    name: 'http.requests.unspecified',
-                    value: 50,
-                    type: 'counter',
-                    aggregationTemporality: 0, // UNSPECIFIED
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 3);
-            const deltaMetric = results.find(m => m.name === 'http.requests.delta');
-            const cumulativeMetric = results.find(m => m.name === 'http.requests.cumulative');
-            const unspecifiedMetric = results.find(m => m.name === 'http.requests.unspecified');
-            assert.strictEqual(deltaMetric?.aggregationTemporality, 'DELTA');
-            assert.strictEqual(cumulativeMetric?.aggregationTemporality, 'CUMULATIVE');
-            assert.strictEqual(unspecifiedMetric?.aggregationTemporality, 'UNSPECIFIED');
-        });
-        it('should normalize aggregationTemporality from string values', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'requests.delta',
-                    value: 100,
-                    type: 'counter',
-                    aggregationTemporality: 'delta', // lowercase
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'requests.cumulative',
-                    value: 500,
-                    type: 'counter',
-                    aggregationTemporality: 'CUMULATIVE', // uppercase
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    name: 'requests.unspecified',
-                    value: 50,
-                    type: 'counter',
-                    aggregationTemporality: 'Unspecified', // mixed case
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 3);
-            const deltaMetric = results.find(m => m.name === 'requests.delta');
-            const cumulativeMetric = results.find(m => m.name === 'requests.cumulative');
-            const unspecifiedMetric = results.find(m => m.name === 'requests.unspecified');
-            assert.strictEqual(deltaMetric?.aggregationTemporality, 'DELTA');
-            assert.strictEqual(cumulativeMetric?.aggregationTemporality, 'CUMULATIVE');
-            assert.strictEqual(unspecifiedMetric?.aggregationTemporality, 'UNSPECIFIED');
-        });
-        it('should return undefined aggregationTemporality when not provided', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'gauge.metric',
-                    value: 42,
-                    type: 'gauge',
-                    // No aggregationTemporality field
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].aggregationTemporality, undefined);
-        });
-        it('should handle invalid aggregationTemporality string values', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'metric.invalid',
-                    value: 100,
-                    type: 'counter',
-                    aggregationTemporality: 'invalid_value',
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            // Invalid values should normalize to UNSPECIFIED
-            assert.strictEqual(results[0].aggregationTemporality, 'UNSPECIFIED');
-        });
-        it('should handle unknown numeric aggregationTemporality values', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'metric.unknown',
-                    value: 100,
-                    type: 'counter',
-                    aggregationTemporality: 99, // Unknown numeric value
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            // Unknown numeric values should normalize to UNSPECIFIED
-            assert.strictEqual(results[0].aggregationTemporality, 'UNSPECIFIED');
-        });
-        it('should read and normalize metrics with exemplars', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'http.request.duration',
-                    value: 150,
-                    type: 'histogram',
-                    unit: 'ms',
-                    histogram: {
-                        buckets: [
-                            { le: 100, count: 10 },
-                            { le: 500, count: 45 },
-                            { le: Infinity, count: 50 },
-                        ],
-                        sum: 7500,
-                        count: 50,
-                    },
-                    exemplars: [
-                        {
-                            timestamp: '2026-01-28T10:00:00.123Z',
-                            value: 450,
-                            traceId: 'abc123def456',
-                            spanId: 'span789',
-                            attributes: { 'http.status_code': 500 },
-                        },
-                        {
-                            timestamp: '2026-01-28T10:00:00.456Z',
-                            value: 95,
-                            traceId: 'xyz789abc123',
-                            spanId: 'span456',
-                        },
-                    ],
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'http.request.duration');
-            assert.ok(results[0].exemplars, 'Exemplars should be present');
-            assert.strictEqual(results[0].exemplars?.length, 2);
-            // Verify first exemplar (high latency with error)
-            const highLatencyExemplar = results[0].exemplars?.[0];
-            assert.strictEqual(highLatencyExemplar?.value, 450);
-            assert.strictEqual(highLatencyExemplar?.traceId, 'abc123def456');
-            assert.strictEqual(highLatencyExemplar?.spanId, 'span789');
-            assert.strictEqual(highLatencyExemplar?.attributes?.['http.status_code'], 500);
-            // Verify second exemplar
-            const normalExemplar = results[0].exemplars?.[1];
-            assert.strictEqual(normalExemplar?.value, 95);
-            assert.strictEqual(normalExemplar?.traceId, 'xyz789abc123');
-        });
-        it('should normalize exemplar timestamps from [seconds, nanoseconds] format', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'api.latency',
-                    value: 200,
-                    type: 'histogram',
-                    exemplars: [
-                        {
-                            timestamp: [1738062000, 123000000], // [seconds, nanoseconds]
-                            value: 350,
-                            traceId: 'trace123',
-                            spanId: 'span456',
-                        },
-                    ],
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            assert.ok(results[0].exemplars);
-            assert.strictEqual(results[0].exemplars?.length, 1);
-            // Timestamp should be converted to ISO string
-            assert.ok(results[0].exemplars?.[0].timestamp.includes('T'));
-            assert.strictEqual(results[0].exemplars?.[0].value, 350);
-        });
-        it('should handle exemplars without optional fields', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'counter.metric',
-                    value: 100,
-                    type: 'counter',
-                    exemplars: [
-                        {
-                            value: 1, // Only required field
-                        },
-                    ],
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            assert.ok(results[0].exemplars);
-            assert.strictEqual(results[0].exemplars?.length, 1);
-            assert.strictEqual(results[0].exemplars?.[0].value, 1);
-            // Timestamp should default to metric timestamp
-            assert.strictEqual(results[0].exemplars?.[0].timestamp, '2026-01-28T10:00:00Z');
-            assert.strictEqual(results[0].exemplars?.[0].traceId, undefined);
-            assert.strictEqual(results[0].exemplars?.[0].spanId, undefined);
-        });
-        it('should handle metrics without exemplars', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'simple.counter',
-                    value: 42,
-                    type: 'counter',
-                    // No exemplars field
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].exemplars, undefined);
-        });
-        it('should handle empty exemplars array', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'empty.exemplars',
-                    value: 100,
-                    type: 'counter',
-                    exemplars: [], // Empty array
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const results = await backend.queryMetrics({});
-            assert.strictEqual(results.length, 1);
-            // Empty exemplars array should result in undefined
-            assert.strictEqual(results[0].exemplars, undefined);
-        });
-    });
-    describe('queryLLMEvents', () => {
-        it('should read and normalize LLM events from JSONL files', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                {
-                    timestamp: '2026-01-28T10:00:00.000Z',
-                    name: 'llm.completion',
-                    attributes: {
-                        'gen_ai.request.model': 'claude-3-opus',
-                        'gen_ai.system': 'anthropic',
-                        'gen_ai.usage.input_tokens': 100,
-                        'gen_ai.usage.output_tokens': 50,
-                        'duration_ms': 1500,
-                        'success': true,
-                    },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'llm.completion');
-            assert.strictEqual(results[0].attributes['gen_ai.request.model'], 'claude-3-opus');
-            assert.strictEqual(results[0].attributes['gen_ai.system'], 'anthropic');
-            assert.strictEqual(results[0].attributes['gen_ai.usage.input_tokens'], 100);
-        });
-        it('should filter events by eventName substring', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'llm.completion', attributes: {} },
-                { timestamp: '2026-01-28T10:01:00Z', name: 'llm.embedding', attributes: {} },
-                { timestamp: '2026-01-28T10:02:00Z', name: 'tool.execution', attributes: {} },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({ eventName: 'llm' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.every(e => e.name.includes('llm')));
-        });
-        it('should filter events by model', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: { 'gen_ai.request.model': 'claude-3-opus' },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'llm.completion',
-                    attributes: { 'gen_ai.request.model': 'gpt-4' },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    name: 'llm.completion',
-                    attributes: { model: 'claude-3-opus' }, // alternate attribute name
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({ model: 'claude-3-opus' });
-            assert.strictEqual(results.length, 2);
-        });
-        it('should filter events by provider', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: { 'gen_ai.system': 'anthropic' },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'llm.completion',
-                    attributes: { 'gen_ai.system': 'openai' },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    name: 'llm.completion',
-                    attributes: { provider: 'anthropic' }, // alternate attribute name
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({ provider: 'anthropic' });
-            assert.strictEqual(results.length, 2);
-        });
-        it('should filter events by search text in attributes', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: { prompt: 'Write a function to calculate fibonacci' },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'llm.completion',
-                    attributes: { prompt: 'Explain quantum computing' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({ search: 'fibonacci' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes.prompt, 'Write a function to calculate fibonacci');
-        });
-        it('should filter events by search text in event name', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'llm.completion.streaming', attributes: {} },
-                { timestamp: '2026-01-28T10:01:00Z', name: 'llm.completion', attributes: {} },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({ search: 'streaming' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'llm.completion.streaming');
-        });
-        it('should apply limit and offset to LLM event results', async () => {
-            const today = getTestDate();
-            const mockEvents = Array.from({ length: 100 }, (_, i) => ({
-                timestamp: new Date(Date.now() + i * 1000).toISOString(),
-                name: `event-${i}`,
-                attributes: { index: i },
-            }));
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({ limit: 20, offset: 50 });
-            assert.strictEqual(results.length, 20);
-            assert.strictEqual(results[0].name, 'event-50');
-        });
-        it('should filter events by date range', async () => {
-            // Create files for multiple dates
-            writeJsonlFile(path.join(tempDir, 'llm-events-2026-01-26.jsonl'), [
-                { timestamp: '2026-01-26T10:00:00Z', name: 'event-26', attributes: {} },
-            ]);
-            writeJsonlFile(path.join(tempDir, 'llm-events-2026-01-27.jsonl'), [
-                { timestamp: '2026-01-27T10:00:00Z', name: 'event-27', attributes: {} },
-            ]);
-            writeJsonlFile(path.join(tempDir, 'llm-events-2026-01-28.jsonl'), [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'event-28', attributes: {} },
-            ]);
-            const results = await backend.queryLLMEvents({
-                startDate: '2026-01-27',
-                endDate: '2026-01-27',
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'event-27');
-        });
-        it('should skip events with missing required fields', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                { timestamp: '2026-01-28T10:00:00Z', name: 'valid-event', attributes: {} },
-                { timestamp: '2026-01-28T10:01:00Z', attributes: {} }, // missing name
-                { name: 'no-timestamp', attributes: {} }, // missing timestamp
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'valid-event');
-        });
-        it('should return empty array when no LLM event files found', async () => {
-            const results = await backend.queryLLMEvents({});
-            assert.strictEqual(results.length, 0);
-        });
-        it('should combine multiple filters', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: { 'gen_ai.request.model': 'claude-3-opus', 'gen_ai.system': 'anthropic' },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'llm.completion',
-                    attributes: { 'gen_ai.request.model': 'gpt-4', 'gen_ai.system': 'openai' },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    name: 'llm.embedding',
-                    attributes: { 'gen_ai.request.model': 'claude-3-opus', 'gen_ai.system': 'anthropic' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({
-                eventName: 'completion',
-                model: 'claude-3-opus',
-                provider: 'anthropic',
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'llm.completion');
-        });
-        it('should use OTel GenAI provider fallback: gen_ai.provider.name -> gen_ai.system -> provider', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: { 'gen_ai.provider.name': 'anthropic-new' }, // should match
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'llm.completion',
-                    attributes: { 'gen_ai.system': 'anthropic-new', 'provider': 'legacy' }, // should match via gen_ai.system
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    name: 'llm.completion',
-                    attributes: { 'provider': 'anthropic-new' }, // should match via provider fallback
-                },
-                {
-                    timestamp: '2026-01-28T10:03:00Z',
-                    name: 'llm.completion',
-                    attributes: { 'gen_ai.provider.name': 'other-provider' }, // should NOT match
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            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 = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.chat',
-                    attributes: { 'gen_ai.operation.name': 'chat' },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'llm.embedding',
-                    attributes: { 'gen_ai.operation.name': 'embeddings' },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    name: 'agent.invoke',
-                    attributes: { 'gen_ai.operation.name': 'invoke_agent' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({ operationName: 'chat' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'llm.chat');
-        });
-        it('should filter events by conversationId', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.chat',
-                    attributes: { 'gen_ai.conversation.id': 'conv-abc123' },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'llm.chat',
-                    attributes: { 'gen_ai.conversation.id': 'conv-xyz789' },
-                },
-                {
-                    timestamp: '2026-01-28T10:02:00Z',
-                    name: 'llm.chat',
-                    attributes: { 'gen_ai.conversation.id': 'conv-abc123' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({ conversationId: 'conv-abc123' });
-            assert.strictEqual(results.length, 2);
-        });
-        it('should combine OTel GenAI filters with other filters', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.chat',
-                    attributes: {
-                        'gen_ai.operation.name': 'chat',
-                        'gen_ai.conversation.id': 'conv-abc123',
-                        'gen_ai.request.model': 'claude-3-opus',
-                    },
-                },
-                {
-                    timestamp: '2026-01-28T10:01:00Z',
-                    name: 'llm.chat',
-                    attributes: {
-                        'gen_ai.operation.name': 'chat',
-                        'gen_ai.conversation.id': 'conv-abc123',
-                        'gen_ai.request.model': 'gpt-4',
-                    },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const results = await backend.queryLLMEvents({
-                operationName: 'chat',
-                conversationId: 'conv-abc123',
-                model: 'claude-3-opus',
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes['gen_ai.request.model'], 'claude-3-opus');
-        });
-    });
-    describe('queryTraces OTel GenAI agent/tool filters', () => {
-        it('should filter traces by agentId', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'agent.invoke',
-                    startTime: [1700000000, 0],
-                    attributes: { 'gen_ai.agent.id': 'agent-001' },
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    name: 'agent.invoke',
-                    startTime: [1700000001, 0],
-                    attributes: { 'gen_ai.agent.id': 'agent-002' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ agentId: 'agent-001' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes?.['gen_ai.agent.id'], 'agent-001');
-        });
-        it('should filter traces by agentName', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'agent.invoke',
-                    startTime: [1700000000, 0],
-                    attributes: { 'gen_ai.agent.name': 'Explore' },
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    name: 'agent.invoke',
-                    startTime: [1700000001, 0],
-                    attributes: { 'gen_ai.agent.name': 'Plan' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ agentName: 'Explore' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes?.['gen_ai.agent.name'], 'Explore');
-        });
-        it('should filter traces by toolName', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'tool.execute',
-                    startTime: [1700000000, 0],
-                    attributes: { 'gen_ai.tool.name': 'Read' },
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    name: 'tool.execute',
-                    startTime: [1700000001, 0],
-                    attributes: { 'gen_ai.tool.name': 'Write' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ toolName: 'Read' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes?.['gen_ai.tool.name'], 'Read');
-        });
-        it('should filter traces by toolCallId', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'tool.execute',
-                    startTime: [1700000000, 0],
-                    attributes: { 'gen_ai.tool.call.id': 'toolu_abc123' },
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    name: 'tool.execute',
-                    startTime: [1700000001, 0],
-                    attributes: { 'gen_ai.tool.call.id': 'toolu_xyz789' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ toolCallId: 'toolu_abc123' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes?.['gen_ai.tool.call.id'], 'toolu_abc123');
-        });
-        it('should filter traces by toolType', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'tool.execute',
-                    startTime: [1700000000, 0],
-                    attributes: { 'gen_ai.tool.type': 'function' },
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    name: 'tool.execute',
-                    startTime: [1700000001, 0],
-                    attributes: { 'gen_ai.tool.type': 'mcp' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ toolType: 'function' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes?.['gen_ai.tool.type'], 'function');
-        });
-        it('should filter traces by operationName', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'llm.call',
-                    startTime: [1700000000, 0],
-                    attributes: { 'gen_ai.operation.name': 'chat' },
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    name: 'tool.execute',
-                    startTime: [1700000001, 0],
-                    attributes: { 'gen_ai.operation.name': 'execute_tool' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({ operationName: 'chat' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes?.['gen_ai.operation.name'], 'chat');
-        });
-        it('should combine agent/tool filters with other trace filters', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'agent.explore',
-                    startTime: [1700000000, 0],
-                    duration: [0, 100000000], // 100ms
-                    attributes: {
-                        'gen_ai.agent.name': 'Explore',
-                        'gen_ai.tool.name': 'Grep',
-                    },
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    name: 'agent.explore',
-                    startTime: [1700000001, 0],
-                    duration: [0, 200000000], // 200ms
-                    attributes: {
-                        'gen_ai.agent.name': 'Explore',
-                        'gen_ai.tool.name': 'Read',
-                    },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({
-                agentName: 'Explore',
-                toolName: 'Grep',
-                spanName: 'agent',
-            });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].attributes?.['gen_ai.tool.name'], 'Grep');
-        });
-    });
-    describe('healthCheck', () => {
-        it('should return error when telemetry directory does not exist', async () => {
-            const nonExistentBackend = new LocalJsonlBackend('/nonexistent/telemetry');
-            const result = await nonExistentBackend.healthCheck();
-            assert.strictEqual(result.status, 'error');
-            assert.match(result.message || '', /not found/);
-        });
-        it('should return ok when directory exists with no files', async () => {
-            // tempDir exists but has no files
-            const result = await backend.healthCheck();
-            assert.strictEqual(result.status, 'ok');
-            assert.match(result.message || '', /No telemetry files/);
-        });
-        it('should return ok with found files message', async () => {
-            const today = getTestDate();
-            // Create both traces and logs files
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), []);
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), []);
-            const result = await backend.healthCheck();
-            assert.strictEqual(result.status, 'ok');
-            assert.match(result.message || '', /traces.*logs/);
-        });
-        it('should include llm-events in health check message', async () => {
-            const today = getTestDate();
-            // Create all three file types
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), []);
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), []);
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), []);
-            const result = await backend.healthCheck();
-            assert.strictEqual(result.status, 'ok');
-            assert.match(result.message || '', /llm-events/);
-        });
-    });
-    describe('date range filtering', () => {
-        it('should filter files by startDate and endDate', async () => {
-            // Create files for multiple dates
-            writeJsonlFile(path.join(tempDir, 'traces-2026-01-26.jsonl'), [
-                { traceId: 'trace-26', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-            ]);
-            writeJsonlFile(path.join(tempDir, 'traces-2026-01-27.jsonl'), [
-                { traceId: 'trace-27', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-            ]);
-            writeJsonlFile(path.join(tempDir, 'traces-2026-01-28.jsonl'), [
-                { traceId: 'trace-28', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-            ]);
-            writeJsonlFile(path.join(tempDir, 'traces-2026-01-29.jsonl'), [
-                { traceId: 'trace-29', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-            ]);
-            const results = await backend.queryTraces({ startDate: '2026-01-27', endDate: '2026-01-28' });
-            assert.strictEqual(results.length, 2);
-            const traceIds = results.map(r => r.traceId);
-            assert.ok(traceIds.includes('trace-27'));
-            assert.ok(traceIds.includes('trace-28'));
-            assert.ok(!traceIds.includes('trace-26'));
-            assert.ok(!traceIds.includes('trace-29'));
-        });
-        it('should use today as default when no date range specified', async () => {
-            const today = getTestDate();
-            const yesterday = new Date(Date.now() - 86400000).toISOString().split('T')[0];
-            // Create file for today and yesterday
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), [
-                { traceId: 'today-trace', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-            ]);
-            writeJsonlFile(path.join(tempDir, `traces-${yesterday}.jsonl`), [
-                { traceId: 'yesterday-trace', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-            ]);
-            // Query with no date range should only get today's data
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'today-trace');
-        });
-    });
-    describe('error handling', () => {
-        it('should handle JSONL parsing errors gracefully', async () => {
-            const today = getTestDate();
-            const filePath = path.join(tempDir, `traces-${today}.jsonl`);
-            // Write malformed JSON
-            fs.writeFileSync(filePath, 'not valid json\n{"traceId":"t1","spanId":"s1","name":"op"}\n', 'utf-8');
-            const results = await backend.queryTraces({});
-            // Should skip the malformed line and parse the valid one
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 't1');
-        });
-        it('should skip spans with invalid time calculations', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'op1',
-                    startTime: [1700000000, 0],
-                    endTime: [1700000000, 0],
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].durationMs, 0);
-        });
-    });
-});
-describe('insertSortedBounded helper', () => {
-    // Test the insertSortedBounded function by observing its behavior
-    // through MultiDirectoryBackend's query methods
-    it('should maintain sorted order by timestamp in traces', async () => {
-        const projectDir = createTempDir();
-        try {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            // Create traces with various timestamps
-            writeJsonlFile(path.join(localTelemetry, `traces-${today}.jsonl`), [
-                { traceId: 'sorted-test-1', spanId: 's1', name: 'SortedTestOp', startTime: [1700000005, 0] },
-                { traceId: 'sorted-test-2', spanId: 's2', name: 'SortedTestOp', startTime: [1700000001, 0] },
-                { traceId: 'sorted-test-3', spanId: 's3', name: 'SortedTestOp', startTime: [1700000009, 0] },
-                { traceId: 'sorted-test-4', spanId: 's4', name: 'SortedTestOp', startTime: [1700000003, 0] },
-                { traceId: 'sorted-test-5', spanId: 's5', name: 'SortedTestOp', startTime: [1700000007, 0] },
-            ]);
-            const backend = new MultiDirectoryBackend(projectDir);
-            const results = await backend.queryTraces({ spanName: 'SortedTestOp' });
-            // Should be sorted by timestamp descending (most recent first)
-            assert.strictEqual(results.length, 5);
-            assert.strictEqual(results[0].traceId, 'sorted-test-3'); // 1700000009
-            assert.strictEqual(results[1].traceId, 'sorted-test-5'); // 1700000007
-            assert.strictEqual(results[2].traceId, 'sorted-test-1'); // 1700000005
-            assert.strictEqual(results[3].traceId, 'sorted-test-4'); // 1700000003
-            assert.strictEqual(results[4].traceId, 'sorted-test-2'); // 1700000001
-        }
-        finally {
-            removeTempDir(projectDir);
-        }
-    });
-    it('should limit results to maxSize efficiently', async () => {
-        const projectDir = createTempDir();
-        try {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            // Create 20 traces
-            writeJsonlFile(path.join(localTelemetry, `traces-${today}.jsonl`), Array.from({ length: 20 }, (_, i) => ({
-                traceId: `bounded-test-${i}`,
-                spanId: `s${i}`,
-                name: 'BoundedTestOp',
-                startTime: [1700000000 + i, 0],
-            })));
-            const backend = new MultiDirectoryBackend(projectDir);
-            const results = await backend.queryTraces({ spanName: 'BoundedTestOp', limit: 5 });
-            // Should return only 5 results
-            assert.strictEqual(results.length, 5);
-            // Results should be sorted by timestamp descending
-            // LocalJsonlBackend returns first 5 found (0-4), then sorted
-            assert.strictEqual(results[0].traceId, 'bounded-test-4'); // highest of 0-4
-            assert.strictEqual(results[4].traceId, 'bounded-test-0'); // lowest of 0-4
-        }
-        finally {
-            removeTempDir(projectDir);
-        }
-    });
-    it('should maintain sorted order in logs', async () => {
-        const projectDir = createTempDir();
-        try {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            writeJsonlFile(path.join(localTelemetry, `logs-${today}.jsonl`), [
-                { timestamp: `${today}T10:00:00Z`, body: 'SortedLogTest_A' },
-                { timestamp: `${today}T12:00:00Z`, body: 'SortedLogTest_B' },
-                { timestamp: `${today}T08:00:00Z`, body: 'SortedLogTest_C' },
-                { timestamp: `${today}T14:00:00Z`, body: 'SortedLogTest_D' },
-            ]);
-            const backend = new MultiDirectoryBackend(projectDir);
-            const results = await backend.queryLogs({ search: 'SortedLogTest' });
-            // Should be sorted by timestamp descending
-            assert.strictEqual(results.length, 4);
-            assert.strictEqual(results[0].body, 'SortedLogTest_D'); // 14:00
-            assert.strictEqual(results[1].body, 'SortedLogTest_B'); // 12:00
-            assert.strictEqual(results[2].body, 'SortedLogTest_A'); // 10:00
-            assert.strictEqual(results[3].body, 'SortedLogTest_C'); // 08:00
-        }
-        finally {
-            removeTempDir(projectDir);
-        }
-    });
-    it('should maintain sorted order in LLM events', async () => {
-        const projectDir = createTempDir();
-        try {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            writeJsonlFile(path.join(localTelemetry, `llm-events-${today}.jsonl`), [
-                { timestamp: `${today}T09:00:00Z`, name: 'SortedLLMTest.A', attributes: {} },
-                { timestamp: `${today}T15:00:00Z`, name: 'SortedLLMTest.B', attributes: {} },
-                { timestamp: `${today}T11:00:00Z`, name: 'SortedLLMTest.C', attributes: {} },
-            ]);
-            const backend = new MultiDirectoryBackend(projectDir);
-            const results = await backend.queryLLMEvents({ eventName: 'SortedLLMTest' });
-            // Should be sorted by timestamp descending
-            assert.strictEqual(results.length, 3);
-            assert.strictEqual(results[0].name, 'SortedLLMTest.B'); // 15:00
-            assert.strictEqual(results[1].name, 'SortedLLMTest.C'); // 11:00
-            assert.strictEqual(results[2].name, 'SortedLLMTest.A'); // 09:00
-        }
-        finally {
-            removeTempDir(projectDir);
-        }
-    });
-});
-describe('streaming JSONL optimization', () => {
-    it('should handle large files with streaming', async () => {
-        const tempDir = createTempDir();
-        try {
-            const today = getTestDate();
-            // Create a file with many records
-            const spans = Array.from({ length: 500 }, (_, i) => ({
-                traceId: `stream-test-${i}`,
-                spanId: `span-${i}`,
-                name: 'StreamTestOp',
-                startTime: [1700000000 + i, 0],
-            }));
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), spans);
-            const backend = new LocalJsonlBackend(tempDir);
-            const results = await backend.queryTraces({ spanName: 'StreamTestOp', limit: 50 });
-            // Should return limited results without loading all into memory
-            assert.strictEqual(results.length, 50);
-        }
-        finally {
-            removeTempDir(tempDir);
-        }
-    });
-    it('should terminate early when limit is reached', async () => {
-        const tempDir = createTempDir();
-        try {
-            const today = getTestDate();
-            // Create file with many records
-            const logs = Array.from({ length: 1000 }, (_, i) => ({
-                timestamp: new Date(Date.now() - i * 1000).toISOString(),
-                body: `StreamingLog_${i}`,
-                severity: 'INFO',
-            }));
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), logs);
-            const backend = new LocalJsonlBackend(tempDir);
-            const start = Date.now();
-            const results = await backend.queryLogs({ search: 'StreamingLog', limit: 10 });
-            const elapsed = Date.now() - start;
-            // Should return quickly with early termination
-            assert.strictEqual(results.length, 10);
-            // Processing should be fast due to early termination
-            assert.ok(elapsed < 1000, `Query took too long: ${elapsed}ms`);
-        }
-        finally {
-            removeTempDir(tempDir);
-        }
-    });
-});
-describe('QueryCache', () => {
-    let tempDir;
-    let backend;
-    before(() => {
-        tempDir = getSharedTempDir('QueryCache');
-    });
-    beforeEach(() => {
-        clearTempDir(tempDir);
-        backend = new LocalJsonlBackend(tempDir);
-    });
-    after(() => {
-        removeSharedTempDir('QueryCache');
-    });
-    describe('caching behavior', () => {
-        it('should return cached results on second query with same options', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'cache-test-1', spanId: 'span1', name: 'test-op', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            // First query - should read from file
-            const result1 = await backend.queryTraces({ spanName: 'test-op' });
-            assert.strictEqual(result1.length, 1);
-            // Modify the file - but cache should return old result
-            const newSpans = [
-                { traceId: 'cache-test-1', spanId: 'span1', name: 'test-op', startTime: [1700000000, 0] },
-                { traceId: 'cache-test-2', spanId: 'span2', name: 'test-op', startTime: [1700000001, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), newSpans);
-            // Second query with same options - should return cached result
-            const result2 = await backend.queryTraces({ spanName: 'test-op' });
-            assert.strictEqual(result2.length, 1, 'Should return cached result, not new file contents');
-        });
-        it('should return fresh results when query options differ', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'cache-test-1', spanId: 'span1', name: 'alpha-op', startTime: [1700000000, 0] },
-                { traceId: 'cache-test-2', spanId: 'span2', name: 'beta-op', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            const result1 = await backend.queryTraces({ spanName: 'alpha' });
-            assert.strictEqual(result1.length, 1);
-            const result2 = await backend.queryTraces({ spanName: 'beta' });
-            assert.strictEqual(result2.length, 1);
-            assert.strictEqual(result2[0].name, 'beta-op');
-        });
-        it('should clear cache when clearCache is called', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'cache-test-1', spanId: 'span1', name: 'clear-test', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            // First query
-            const result1 = await backend.queryTraces({ spanName: 'clear-test' });
-            assert.strictEqual(result1.length, 1);
-            // Modify the file
-            const newSpans = [
-                { traceId: 'cache-test-1', spanId: 'span1', name: 'clear-test', startTime: [1700000000, 0] },
-                { traceId: 'cache-test-2', spanId: 'span2', name: 'clear-test', startTime: [1700000001, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), newSpans);
-            // Clear cache
-            backend.clearCache();
-            // Query again - should read fresh data
-            const result2 = await backend.queryTraces({ spanName: 'clear-test' });
-            assert.strictEqual(result2.length, 2, 'Should return fresh results after cache clear');
-        });
-        it('should cache logs query results', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: `${today}T10:00:00Z`, body: 'Test log message', severity: 'INFO' },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            const result1 = await backend.queryLogs({ search: 'Test' });
-            assert.strictEqual(result1.length, 1);
-            // Add another log to file
-            const newLogs = [
-                { timestamp: `${today}T10:00:00Z`, body: 'Test log message', severity: 'INFO' },
-                { timestamp: `${today}T11:00:00Z`, body: 'Another Test log', severity: 'INFO' },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), newLogs);
-            // Should return cached result
-            const result2 = await backend.queryLogs({ search: 'Test' });
-            assert.strictEqual(result2.length, 1, 'Should return cached logs result');
-        });
-        it('should cache metrics query results', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: `${today}T10:00:00Z`, name: 'test.metric', value: 100, type: 'gauge' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), mockMetrics);
-            const result1 = await backend.queryMetrics({ metricName: 'test.metric' });
-            assert.strictEqual(result1.length, 1);
-            // Add another metric to file
-            const newMetrics = [
-                { timestamp: `${today}T10:00:00Z`, name: 'test.metric', value: 100, type: 'gauge' },
-                { timestamp: `${today}T11:00:00Z`, name: 'test.metric', value: 200, type: 'gauge' },
-            ];
-            writeJsonlFile(path.join(tempDir, `metrics-${today}.jsonl`), newMetrics);
-            // Should return cached result
-            const result2 = await backend.queryMetrics({ metricName: 'test.metric' });
-            assert.strictEqual(result2.length, 1, 'Should return cached metrics result');
-        });
-        it('should cache LLM events query results', async () => {
-            const today = getTestDate();
-            const mockEvents = [
-                { timestamp: `${today}T10:00:00Z`, name: 'llm.call', attributes: { model: 'claude' } },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
-            const result1 = await backend.queryLLMEvents({ eventName: 'llm.call' });
-            assert.strictEqual(result1.length, 1);
-            // Add another event to file
-            const newEvents = [
-                { timestamp: `${today}T10:00:00Z`, name: 'llm.call', attributes: { model: 'claude' } },
-                { timestamp: `${today}T11:00:00Z`, name: 'llm.call', attributes: { model: 'gpt' } },
-            ];
-            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), newEvents);
-            // Should return cached result
-            const result2 = await backend.queryLLMEvents({ eventName: 'llm.call' });
-            assert.strictEqual(result2.length, 1, 'Should return cached LLM events result');
-        });
-    });
-    describe('getCacheStats', () => {
-        it('should return correct cache stats structure', () => {
-            const stats = backend.getCacheStats();
-            assert.ok(stats.traces, 'Should have traces stats');
-            assert.ok(stats.logs, 'Should have logs stats');
-            assert.ok(stats.metrics, 'Should have metrics stats');
-            assert.ok(stats.llmEvents, 'Should have llmEvents stats');
-            // Check structure of each cache stat
-            for (const key of ['traces', 'logs', 'metrics', 'llmEvents']) {
-                const stat = stats[key];
-                assert.strictEqual(typeof stat.hits, 'number', `${key} should have hits`);
-                assert.strictEqual(typeof stat.misses, 'number', `${key} should have misses`);
-                assert.strictEqual(typeof stat.evictions, 'number', `${key} should have evictions`);
-                assert.strictEqual(typeof stat.size, 'number', `${key} should have size`);
-                assert.strictEqual(typeof stat.hitRate, 'number', `${key} should have hitRate`);
-            }
-        });
-        it('should track cache hits and misses', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'stats-test-1', spanId: 'span1', name: 'test-op', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            // Initial stats should be zero
-            let stats = backend.getCacheStats();
-            assert.strictEqual(stats.traces.hits, 0);
-            assert.strictEqual(stats.traces.misses, 0);
-            // First query - cache miss
-            await backend.queryTraces({ spanName: 'test-op' });
-            stats = backend.getCacheStats();
-            assert.strictEqual(stats.traces.misses, 1);
-            assert.strictEqual(stats.traces.hits, 0);
-            // Second query with same options - cache hit
-            await backend.queryTraces({ spanName: 'test-op' });
-            stats = backend.getCacheStats();
-            assert.strictEqual(stats.traces.hits, 1);
-            assert.strictEqual(stats.traces.misses, 1);
-            assert.ok(stats.traces.hitRate > 0, 'Hit rate should be > 0');
-        });
-    });
-    describe('indexed queries', () => {
-        it('should use index for trace queries when available', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'user-create', startTime: [1700000000, 0], resource: { serviceName: 'service-a' } },
-                { traceId: 'trace2', spanId: 'span2', name: 'db-query', startTime: [1700000001, 0], resource: { serviceName: 'service-b' } },
-                { traceId: 'trace1', spanId: 'span3', name: 'user-update', startTime: [1700000002, 0], resource: { serviceName: 'service-a' } },
-            ];
-            const filePath = path.join(tempDir, `traces-${today}.jsonl`);
-            writeJsonlFile(filePath, mockSpans);
-            // Build index for the file
-            await buildAndWriteIndex(filePath, 'traces');
-            // Query should use the index
-            const results = await backend.queryTraces({ traceId: 'trace1' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.every(s => s.traceId === 'trace1'));
-        });
-        it('should fall back to full scan when no index exists', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'op2', startTime: [1700000001, 0] },
-            ];
-            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
-            // No index built - should still work via full scan
-            const results = await backend.queryTraces({ traceId: 'trace1' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-        it('should use index for log queries when available', async () => {
-            const today = getTestDate();
-            const mockLogs = [
-                { timestamp: `${today}T10:00:00Z`, severityText: 'ERROR', body: 'Error occurred', traceId: 'trace1' },
-                { timestamp: `${today}T10:01:00Z`, severityText: 'INFO', body: 'Info message', traceId: 'trace2' },
-                { timestamp: `${today}T10:02:00Z`, severityText: 'ERROR', body: 'Another error', traceId: 'trace3' },
-            ];
-            const filePath = path.join(tempDir, `logs-${today}.jsonl`);
-            writeJsonlFile(filePath, mockLogs);
-            // Build index for the file
-            await buildAndWriteIndex(filePath, 'logs');
-            // Query should use the index
-            const results = await backend.queryLogs({ severity: 'ERROR' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.every(l => l.severity === 'ERROR'));
-        });
-        it('should use index for metric queries when available', async () => {
-            const today = getTestDate();
-            const mockMetrics = [
-                { timestamp: `${today}T10:00:00Z`, name: 'http.request.duration', value: 100 },
-                { timestamp: `${today}T10:01:00Z`, name: 'db.query.count', value: 50 },
-                { timestamp: `${today}T10:02:00Z`, name: 'http.request.size', value: 1024 },
-            ];
-            const filePath = path.join(tempDir, `metrics-${today}.jsonl`);
-            writeJsonlFile(filePath, mockMetrics);
-            // Build index for the file
-            await buildAndWriteIndex(filePath, 'metrics');
-            // Query should use the index
-            const results = await backend.queryMetrics({ metricName: 'http' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.every(m => m.name.includes('http')));
-        });
-        it('should apply non-indexable filters after index lookup', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'user-create',
-                    startTime: [1700000000, 0],
-                    endTime: [1700000000, 500000000], // 500ms duration
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    name: 'user-update',
-                    startTime: [1700000000, 0],
-                    endTime: [1700000002, 0], // 2s duration
-                },
-            ];
-            const filePath = path.join(tempDir, `traces-${today}.jsonl`);
-            writeJsonlFile(filePath, mockSpans);
-            // Build index
-            await buildAndWriteIndex(filePath, 'traces');
-            // Query with both indexable (traceId) and non-indexable (minDurationMs) filters
-            const results = await backend.queryTraces({ traceId: 'trace1', minDurationMs: 1000 });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].name, 'user-update');
-        });
-        it('should work correctly when index is stale', async () => {
-            const today = getTestDate();
-            const filePath = path.join(tempDir, `traces-${today}.jsonl`);
-            // Create initial file and index
-            const initialSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-            ];
-            writeJsonlFile(filePath, initialSpans);
-            await buildAndWriteIndex(filePath, 'traces');
-            // Modify the file to make index stale
-            await new Promise(resolve => setTimeout(resolve, 10));
-            const updatedSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'op2', startTime: [1700000001, 0] },
-            ];
-            writeJsonlFile(filePath, updatedSpans);
-            // Query should fall back to full scan and find both spans
-            const results = await backend.queryTraces({});
-            assert.strictEqual(results.length, 2);
-        });
-        it('should respect useIndexes=false constructor option', async () => {
-            const today = getTestDate();
-            const mockSpans = [
-                { traceId: 'trace1', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
-                { traceId: 'trace2', spanId: 'span2', name: 'op2', startTime: [1700000001, 0] },
-            ];
-            const filePath = path.join(tempDir, `traces-${today}.jsonl`);
-            writeJsonlFile(filePath, mockSpans);
-            await buildAndWriteIndex(filePath, 'traces');
-            // Create backend with indexes disabled
-            const noIndexBackend = new LocalJsonlBackend(tempDir, false);
-            // Should still work via full scan
-            const results = await noIndexBackend.queryTraces({ traceId: 'trace1' });
-            assert.strictEqual(results.length, 1);
-            assert.strictEqual(results[0].traceId, 'trace1');
-        });
-    });
-});
-describe('MultiDirectoryBackend', () => {
-    let projectDir;
-    before(() => {
-        projectDir = getSharedTempDir('MultiDirectoryBackend');
-    });
-    beforeEach(() => {
-        // Clear project directory for each test
-        clearTempDir(projectDir);
-    });
-    after(() => {
-        removeSharedTempDir('MultiDirectoryBackend');
-    });
-    describe('constructor and getDirectories', () => {
-        it('should return directories when local telemetry dirs exist', () => {
-            // Create local telemetry directory
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            const backend = new MultiDirectoryBackend(projectDir);
-            const dirs = backend.getDirectories();
-            assert.ok(Array.isArray(dirs));
-            // 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', () => {
-            const backend = new MultiDirectoryBackend(projectDir);
-            assert.strictEqual(backend.name, 'multi-directory');
-        });
-        it('should detect .telemetry local directory', () => {
-            const localTelemetry = path.join(projectDir, '.telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            const backend = new MultiDirectoryBackend(projectDir);
-            const dirs = backend.getDirectories();
-            // 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');
-        });
-        it('should detect .claude/telemetry local directory', () => {
-            const localTelemetry = path.join(projectDir, '.claude', 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            const backend = new MultiDirectoryBackend(projectDir);
-            const dirs = backend.getDirectories();
-            // 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');
-        });
-    });
-    describe('queryTraces', () => {
-        it('should query traces from local telemetry directory', async () => {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            // Create traces in local directory with unique IDs
-            writeJsonlFile(path.join(localTelemetry, `traces-${today}.jsonl`), [
-                { traceId: 'multidir-unique-test-abc123-1', spanId: 'span1', name: 'MultiDirUniqueOp_XYZ', startTime: [1700000000, 0] },
-                { traceId: 'multidir-unique-test-abc123-2', spanId: 'span2', name: 'MultiDirUniqueOp_XYZ', startTime: [1700000002, 0] },
-            ]);
-            const backend = new MultiDirectoryBackend(projectDir);
-            // Use spanName filter to find our specific test traces
-            const results = await backend.queryTraces({ spanName: 'MultiDirUniqueOp_XYZ' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.some(t => t.traceId === 'multidir-unique-test-abc123-1'), 'Should find test trace 1');
-            assert.ok(results.some(t => t.traceId === 'multidir-unique-test-abc123-2'), 'Should find test trace 2');
-        });
-        it('should merge and sort traces by timestamp', async () => {
-            const today = getTestDate();
-            // Create two local telemetry directories
-            const localTelemetry1 = path.join(projectDir, 'telemetry');
-            const localTelemetry2 = path.join(projectDir, '.telemetry');
-            fs.mkdirSync(localTelemetry1, { recursive: true });
-            fs.mkdirSync(localTelemetry2, { recursive: true });
-            // Create traces with different timestamps and unique operation name
-            writeJsonlFile(path.join(localTelemetry1, `traces-${today}.jsonl`), [
-                { traceId: 'multidir-sort-old-xyz789', spanId: 'span1', name: 'MultiDirSortOp_ABC', startTime: [1700000000, 0] },
-            ]);
-            writeJsonlFile(path.join(localTelemetry2, `traces-${today}.jsonl`), [
-                { traceId: 'multidir-sort-new-xyz789', spanId: 'span2', name: 'MultiDirSortOp_ABC', startTime: [1700000010, 0] },
-            ]);
-            const backend = new MultiDirectoryBackend(projectDir);
-            const results = await backend.queryTraces({ spanName: 'MultiDirSortOp_ABC' });
-            assert.strictEqual(results.length, 2);
-            // Newer trace should be first (sorted by startTimeUnixNano descending)
-            assert.strictEqual(results[0].traceId, 'multidir-sort-new-xyz789');
-            assert.strictEqual(results[1].traceId, 'multidir-sort-old-xyz789');
-        });
-        it('should respect limit parameter', async () => {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            // Create many traces with unique prefix
-            writeJsonlFile(path.join(localTelemetry, `traces-${today}.jsonl`), Array.from({ length: 150 }, (_, i) => ({
-                traceId: `multidir-limit-trace-${i}`,
-                spanId: `span${i}`,
-                name: `MultiDirLimitOp_${i}`,
-                startTime: [1700000000 + i, 0],
-            })));
-            const backend = new MultiDirectoryBackend(projectDir);
-            const results = await backend.queryTraces({ spanName: 'MultiDirLimitOp', limit: 50 });
-            assert.ok(results.length <= 50);
-        });
-    });
-    describe('queryLogs', () => {
-        it('should query logs from local telemetry directory', async () => {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            writeJsonlFile(path.join(localTelemetry, `logs-${today}.jsonl`), [
-                { timestamp: `${today}T10:00:00Z`, body: 'MultiDirUniqueTestLog_ABC123_1', severity: 'INFO' },
-                { timestamp: `${today}T11:00:00Z`, body: 'MultiDirUniqueTestLog_ABC123_2', severity: 'ERROR' },
-            ]);
-            const backend = new MultiDirectoryBackend(projectDir);
-            // Use search filter to find our specific test logs
-            const results = await backend.queryLogs({ search: 'MultiDirUniqueTestLog_ABC123' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.some(l => l.body === 'MultiDirUniqueTestLog_ABC123_1'), 'Should find test log 1');
-            assert.ok(results.some(l => l.body === 'MultiDirUniqueTestLog_ABC123_2'), 'Should find test log 2');
-        });
-        it('should sort logs by timestamp descending', async () => {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            writeJsonlFile(path.join(localTelemetry, `logs-${today}.jsonl`), [
-                { timestamp: `${today}T08:00:00Z`, body: 'MultiDirSortTest_Early', severity: 'INFO' },
-                { timestamp: `${today}T12:00:00Z`, body: 'MultiDirSortTest_Late', severity: 'INFO' },
-            ]);
-            const backend = new MultiDirectoryBackend(projectDir);
-            const results = await backend.queryLogs({ search: 'MultiDirSortTest' });
-            assert.strictEqual(results.length, 2);
-            // Later log should come first (sorted descending)
-            assert.strictEqual(results[0].body, 'MultiDirSortTest_Late');
-            assert.strictEqual(results[1].body, 'MultiDirSortTest_Early');
-        });
-    });
-    describe('queryMetrics', () => {
-        it('should query metrics from local telemetry directory', async () => {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            writeJsonlFile(path.join(localTelemetry, `metrics-${today}.jsonl`), [
-                { timestamp: `${today}T10:00:00Z`, name: 'multidir.unique.xyz789.metric1', value: 100, type: 'gauge' },
-                { timestamp: `${today}T11:00:00Z`, name: 'multidir.unique.xyz789.metric2', value: 200, type: 'gauge' },
-            ]);
-            const backend = new MultiDirectoryBackend(projectDir);
-            // Use metricName filter to find our specific test metrics
-            const results = await backend.queryMetrics({ metricName: 'multidir.unique.xyz789' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.some(m => m.name === 'multidir.unique.xyz789.metric1'), 'Should find test metric 1');
-            assert.ok(results.some(m => m.name === 'multidir.unique.xyz789.metric2'), 'Should find test metric 2');
-        });
-        it('should respect limit parameter', async () => {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            writeJsonlFile(path.join(localTelemetry, `metrics-${today}.jsonl`), Array.from({ length: 150 }, (_, i) => ({
-                timestamp: `${today}T10:${String(Math.floor(i / 60) % 60).padStart(2, '0')}:${String(i % 60).padStart(2, '0')}Z`,
-                name: `multidir.limit.abc123.metric-${i}`,
-                value: i * 10,
-                type: 'gauge',
-            })));
-            const backend = new MultiDirectoryBackend(projectDir);
-            const results = await backend.queryMetrics({ metricName: 'multidir.limit.abc123', limit: 50 });
-            assert.ok(results.length <= 50);
-        });
-    });
-    describe('queryLLMEvents', () => {
-        it('should query LLM events from local telemetry directory', async () => {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            writeJsonlFile(path.join(localTelemetry, `llm-events-${today}.jsonl`), [
-                { timestamp: `${today}T10:00:00Z`, name: 'multidir.unique.xyz456.llm.event1', attributes: { model: 'claude' } },
-                { timestamp: `${today}T11:00:00Z`, name: 'multidir.unique.xyz456.llm.event2', attributes: { model: 'gpt' } },
-            ]);
-            const backend = new MultiDirectoryBackend(projectDir);
-            // Use eventName filter to find our specific test events
-            const results = await backend.queryLLMEvents({ eventName: 'multidir.unique.xyz456' });
-            assert.strictEqual(results.length, 2);
-            assert.ok(results.some(e => e.name === 'multidir.unique.xyz456.llm.event1'), 'Should find test event 1');
-            assert.ok(results.some(e => e.name === 'multidir.unique.xyz456.llm.event2'), 'Should find test event 2');
-        });
-        it('should sort LLM events by timestamp descending', async () => {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            writeJsonlFile(path.join(localTelemetry, `llm-events-${today}.jsonl`), [
-                { timestamp: `${today}T08:00:00Z`, name: 'multidir.sort.abc789.early', attributes: {} },
-                { timestamp: `${today}T12:00:00Z`, name: 'multidir.sort.abc789.late', attributes: {} },
-            ]);
-            const backend = new MultiDirectoryBackend(projectDir);
-            const results = await backend.queryLLMEvents({ eventName: 'multidir.sort.abc789' });
-            assert.strictEqual(results.length, 2);
-            // Later event should be first (sorted descending)
-            assert.strictEqual(results[0].name, 'multidir.sort.abc789.late');
-            assert.strictEqual(results[1].name, 'multidir.sort.abc789.early');
-        });
-    });
-    describe('healthCheck', () => {
-        it('should return error when no directories found', async () => {
-            // Create a backend with cwd that has no telemetry directories
-            // AND ensure global telemetry doesn't exist for this test
-            const emptyProject = createTempDir();
-            try {
-                const backend = new MultiDirectoryBackend(emptyProject);
-                // Only test error condition if we actually have no directories
-                if (backend.getDirectories().length === 0) {
-                    const health = await backend.healthCheck();
-                    assert.strictEqual(health.status, 'error');
-                    assert.ok(health.message?.includes('No telemetry directories'));
-                }
-            }
-            finally {
-                removeTempDir(emptyProject);
-            }
-        });
-        it('should return ok when local telemetry directory exists', async () => {
-            const today = getTestDate();
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            // Create some telemetry files
-            writeJsonlFile(path.join(localTelemetry, `traces-${today}.jsonl`), []);
-            const backend = new MultiDirectoryBackend(projectDir);
-            const health = await backend.healthCheck();
-            assert.strictEqual(health.status, 'ok');
-            assert.ok(health.directories);
-            assert.ok(health.directories.length > 0);
-        });
-        it('should include directory statuses in health response', async () => {
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            const backend = new MultiDirectoryBackend(projectDir);
-            const health = await backend.healthCheck();
-            if (health.directories) {
-                for (const dir of health.directories) {
-                    assert.ok(dir.path);
-                    assert.ok(dir.source);
-                    assert.ok(dir.status);
-                }
-            }
-        });
-        it('should report correct directory count in message', async () => {
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            const backend = new MultiDirectoryBackend(projectDir);
-            const health = await backend.healthCheck();
-            assert.ok(health.message?.includes('telemetry director'));
-        });
-    });
-    describe('getCacheStats', () => {
-        it('should return aggregated cache stats from all backends', () => {
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            const backend = new MultiDirectoryBackend(projectDir);
-            const stats = backend.getCacheStats();
-            assert.ok(stats.traces, 'Should have traces stats');
-            assert.ok(stats.logs, 'Should have logs stats');
-            assert.ok(stats.metrics, 'Should have metrics stats');
-            assert.ok(stats.llmEvents, 'Should have llmEvents stats');
-        });
-        it('should have correct structure for aggregated stats', () => {
-            const localTelemetry = path.join(projectDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            const backend = new MultiDirectoryBackend(projectDir);
-            const stats = backend.getCacheStats();
-            for (const key of ['traces', 'logs', 'metrics', 'llmEvents']) {
-                const stat = stats[key];
-                assert.strictEqual(typeof stat.hits, 'number', `${key} should have hits`);
-                assert.strictEqual(typeof stat.misses, 'number', `${key} should have misses`);
-                assert.strictEqual(typeof stat.evictions, 'number', `${key} should have evictions`);
-                assert.strictEqual(typeof stat.size, 'number', `${key} should have size`);
-                assert.strictEqual(typeof stat.hitRate, 'number', `${key} should have hitRate`);
-                assert.ok(stat.hitRate >= 0 && stat.hitRate <= 1, `${key} hitRate should be between 0 and 1`);
-            }
-        });
-    });
-});
-/**
- * OTLP Export Tests
- */
-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();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    parentSpanId: undefined,
-                    name: 'root-span',
-                    kind: 1, // SERVER
-                    startTime: [1700000000, 0],
-                    endTime: [1700000001, 500000000],
-                    status: { code: 1, message: 'OK' },
-                    resource: { serviceName: 'test-service', serviceVersion: '1.0.0' },
-                    attributes: { 'http.method': 'GET', 'http.status_code': 200 },
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    parentSpanId: 'span1',
-                    name: 'db-query',
-                    kind: 2, // CLIENT
-                    startTime: [1700000000, 100000000],
-                    endTime: [1700000000, 500000000],
-                    status: { code: 1 },
-                    resource: { serviceName: 'test-service' },
-                    attributes: { 'db.system': 'postgresql' },
-                },
-            ];
-            writeJsonlFile(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();
-            const mockSpans = [
-                {
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    name: 'service-a-op',
-                    startTime: [1700000000, 0],
-                    resource: { serviceName: 'service-a' },
-                },
-                {
-                    traceId: 'trace1',
-                    spanId: 'span2',
-                    name: 'service-b-op',
-                    startTime: [1700000000, 0],
-                    resource: { serviceName: 'service-b' },
-                },
-            ];
-            writeJsonlFile(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();
-            const mockLogs = [
-                {
-                    timestamp: '2024-01-15T10:00:00.000Z',
-                    severityText: 'ERROR',
-                    body: 'Database connection failed',
-                    traceId: 'trace1',
-                    spanId: 'span1',
-                    resource: { serviceName: 'test-service' },
-                    attributes: { 'error.type': 'ConnectionError' },
-                },
-                {
-                    timestamp: '2024-01-15T10:00:01.000Z',
-                    severityText: 'INFO',
-                    body: 'Request processed',
-                    resource: { serviceName: 'test-service' },
-                },
-            ];
-            writeJsonlFile(path.join(tempDir, `logs-${today}.jsonl`), mockLogs);
-            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();
-            const mockMetrics = [
-                {
-                    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' },
-                },
-            ];
-            writeJsonlFile(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();
-            const mockMetrics = [
-                {
-                    timestamp: '2024-01-15T10:00:00.000Z',
-                    name: 'http.requests',
-                    value: 100,
-                    type: 'counter',
-                    unit: 'requests',
-                    aggregationTemporality: 2, // CUMULATIVE
-                    resource: { serviceName: 'test-service' },
-                },
-            ];
-            writeJsonlFile(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();
-            const mockMetrics = [
-                {
-                    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' },
-                },
-            ];
-            writeJsonlFile(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();
-            const mockMetrics = [
-                {
-                    timestamp: '2024-01-15T10:00:00.000Z',
-                    name: 'http.latency',
-                    value: 150,
-                    type: 'gauge',
-                    unit: 'ms',
-                    exemplars: [
-                        {
-                            timestamp: '2024-01-15T10:00:00.000Z',
-                            value: 150,
-                            traceId: 'trace123',
-                            spanId: 'span456',
-                        },
-                    ],
-                    resource: { serviceName: 'test-service' },
-                },
-            ];
-            writeJsonlFile(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();
-            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