observability-toolkit 1.3.0 → 1.5.0

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

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