observability-toolkit 1.1.0 → 1.4.0

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

@@ -0,0 +1,1638 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import * as assert from 'node:assert';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { LocalJsonlBackend, MultiDirectoryBackend } from './local-jsonl.js';
+/**
+ * Test utilities for creating temp test fixtures
+ */
+function createTempDir() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'local-jsonl-test-'));
+}
+function removeTempDir(dir) {
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+function writeJsonlFile(filePath, data) {
+    const content = data.map(item => JSON.stringify(item)).join('\n');
+    fs.writeFileSync(filePath, content, 'utf-8');
+}
+function getTestDate() {
+    return new Date().toISOString().split('T')[0];
+}
+describe('LocalJsonlBackend', () => {
+    let tempDir;
+    let backend;
+    beforeEach(() => {
+        tempDir = createTempDir();
+        backend = new LocalJsonlBackend(tempDir);
+    });
+    afterEach(() => {
+        removeTempDir(tempDir);
+    });
+    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 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 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');
+        });
+    });
+    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 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');
+        });
+    });
+    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 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);
+        });
+    });
+    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');
+        });
+    });
+    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('MultiDirectoryBackend', () => {
+    let projectDir;
+    beforeEach(() => {
+        // Create a project directory that will have local telemetry subdirectories
+        projectDir = createTempDir();
+    });
+    afterEach(() => {
+        removeTempDir(projectDir);
+    });
+    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
+            const localDir = dirs.find(d => d.source === 'local' && d.path === localTelemetry);
+            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();
+            const localDir = dirs.find(d => d.path === localTelemetry);
+            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();
+            const localDir = dirs.find(d => d.path === localTelemetry);
+            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'));
+        });
+    });
+});
+//# sourceMappingURL=local-jsonl.test.js.map