observability-toolkit 1.8.2 → 1.8.5

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

@@ -0,0 +1,1729 @@
+import { describe, it, before, after, beforeEach } from 'node:test';
+import * as assert from 'node:assert';
+import * as path from 'path';
+import { LocalJsonlBackend } from './local-jsonl.js';
+import { getSharedTempDir, clearTempDir, removeSharedTempDir, writeJsonlFileAsync, getTestDate } from '../test-helpers/file-utils.js';
+import { createMockSpan, createMockSpans, createDbSpan, resetBuilderCounters, } from '../test-helpers/test-data-builders.js';
+describe('LocalJsonlBackend', () => {
+    let tempDir;
+    let backend;
+    before(() => {
+        tempDir = getSharedTempDir('LocalJsonlBackend-Traces');
+    });
+    beforeEach(() => {
+        clearTempDir(tempDir);
+        backend = new LocalJsonlBackend(tempDir);
+    });
+    after(() => {
+        removeSharedTempDir('LocalJsonlBackend-Traces');
+    });
+    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' },
+                },
+            ];
+            await writeJsonlFileAsync(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();
+            resetBuilderCounters();
+            // Use createMockSpan with explicit traceId overrides
+            const mockSpans = [
+                createMockSpan({ traceId: 'trace1', spanId: 'span1', name: 'op1' }),
+                createMockSpan({ traceId: 'trace2', spanId: 'span2', name: 'op2' }),
+                createMockSpan({ traceId: 'trace1', spanId: 'span3', name: 'op3' }),
+            ];
+            await writeJsonlFileAsync(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();
+            resetBuilderCounters();
+            // Use createMockSpan for simple spans with specific names
+            const mockSpans = [
+                createMockSpan({ traceId: 'trace1', name: 'user-create' }),
+                createMockSpan({ traceId: 'trace1', name: 'user-update' }),
+                createDbSpan('query', 'postgres', { traceId: 'trace1' }),
+            ];
+            await writeJsonlFileAsync(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
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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();
+            resetBuilderCounters();
+            // Use createMockSpans with dynamic overrides for indexed data
+            const mockSpans = createMockSpans(150, (i) => ({
+                traceId: `trace${i}`,
+                spanId: `span${i}`,
+                name: `op${i}`,
+            }));
+            await writeJsonlFileAsync(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
+            ];
+            await writeJsonlFileAsync(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
+                },
+            ];
+            await writeJsonlFileAsync(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] },
+            ];
+            await writeJsonlFileAsync(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' } },
+            ];
+            await writeJsonlFileAsync(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] },
+            ];
+            await writeJsonlFileAsync(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],
+                },
+            ];
+            await writeJsonlFileAsync(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],
+                },
+            ];
+            await writeJsonlFileAsync(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 },
+                        },
+                    ],
+                },
+            ];
+            await writeJsonlFileAsync(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' } },
+                    ],
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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 },
+                },
+            ];
+            await writeJsonlFileAsync(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 },
+                },
+            ];
+            await writeJsonlFileAsync(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 },
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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] },
+            ];
+            await writeJsonlFileAsync(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] },
+            ];
+            await writeJsonlFileAsync(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] },
+            ];
+            await writeJsonlFileAsync(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] },
+            ];
+            await writeJsonlFileAsync(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] },
+            ];
+            await writeJsonlFileAsync(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] },
+            ];
+            await writeJsonlFileAsync(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
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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] },
+            ];
+            await writeJsonlFileAsync(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
+                },
+            ];
+            await writeJsonlFileAsync(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 },
+                },
+            ];
+            await writeJsonlFileAsync(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 },
+                },
+            ];
+            await writeJsonlFileAsync(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 },
+                },
+            ];
+            await writeJsonlFileAsync(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 },
+                },
+            ];
+            await writeJsonlFileAsync(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 },
+                },
+            ];
+            await writeJsonlFileAsync(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 },
+                },
+            ];
+            await writeJsonlFileAsync(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
+                },
+            ];
+            await writeJsonlFileAsync(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
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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] },
+            ];
+            await writeJsonlFileAsync(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('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,
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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: {} },
+            ];
+            await writeJsonlFileAsync(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
+                },
+            ];
+            await writeJsonlFileAsync(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
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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: {} },
+            ];
+            await writeJsonlFileAsync(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 },
+            }));
+            await writeJsonlFileAsync(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
+            await writeJsonlFileAsync(path.join(tempDir, 'llm-events-2026-01-26.jsonl'), [
+                { timestamp: '2026-01-26T10:00:00Z', name: 'event-26', attributes: {} },
+            ]);
+            await writeJsonlFileAsync(path.join(tempDir, 'llm-events-2026-01-27.jsonl'), [
+                { timestamp: '2026-01-27T10:00:00Z', name: 'event-27', attributes: {} },
+            ]);
+            await writeJsonlFileAsync(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
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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
+                },
+            ];
+            await writeJsonlFileAsync(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',
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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',
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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',
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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',
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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',
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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',
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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',
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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',
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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',
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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',
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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' },
+                },
+            ];
+            await writeJsonlFileAsync(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',
+                    },
+                },
+            ];
+            await writeJsonlFileAsync(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');
+        });
+    });
+});
+//# sourceMappingURL=local-jsonl-traces.test.js.map