observability-toolkit 1.5.0 → 1.8.0

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

@@ -993,6 +993,19 @@ describe('LocalJsonlBackend', () => {
             assert.strictEqual(results.length, 1);
             assert.strictEqual(results[0].traceId, 'trace1');
         });
+        it('should complete queries with timing (timing is logged for slow queries)', async () => {
+            // This test verifies that query timing is active and doesn't break normal queries
+            // Timing warnings are logged for queries > 500ms
+            const today = getTestDate();
+            const mockSpans = [
+                { traceId: 'trace1', spanId: 'span1', name: 'op1', startTime: [1700000000, 0] },
+                { traceId: 'trace2', spanId: 'span2', name: 'op2', startTime: [1700000001, 0] },
+            ];
+            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
+            // Query should complete successfully with timing active
+            const results = await backend.queryTraces({});
+            assert.strictEqual(results.length, 2);
+        });
     });
     describe('queryLogs', () => {
         it('should read and normalize log records from JSONL files', async () => {
@@ -2623,6 +2636,287 @@ describe('LocalJsonlBackend', () => {
             assert.strictEqual(results.length, 1);
             assert.strictEqual(results[0].name, 'llm.completion');
         });
+        it('should use OTel GenAI provider fallback: gen_ai.provider.name -> gen_ai.system -> provider', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.completion',
+                    attributes: { 'gen_ai.provider.name': 'anthropic-new' }, // should match
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.completion',
+                    attributes: { 'gen_ai.system': 'anthropic-new', 'provider': 'legacy' }, // should match via gen_ai.system
+                },
+                {
+                    timestamp: '2026-01-28T10:02:00Z',
+                    name: 'llm.completion',
+                    attributes: { 'provider': 'anthropic-new' }, // should match via provider fallback
+                },
+                {
+                    timestamp: '2026-01-28T10:03:00Z',
+                    name: 'llm.completion',
+                    attributes: { 'gen_ai.provider.name': 'other-provider' }, // should NOT match
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({ provider: 'anthropic-new' });
+            assert.strictEqual(results.length, 3);
+        });
+        it('should filter events by operationName', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.chat',
+                    attributes: { 'gen_ai.operation.name': 'chat' },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.embedding',
+                    attributes: { 'gen_ai.operation.name': 'embeddings' },
+                },
+                {
+                    timestamp: '2026-01-28T10:02:00Z',
+                    name: 'agent.invoke',
+                    attributes: { 'gen_ai.operation.name': 'invoke_agent' },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({ operationName: 'chat' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].name, 'llm.chat');
+        });
+        it('should filter events by conversationId', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.chat',
+                    attributes: { 'gen_ai.conversation.id': 'conv-abc123' },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.chat',
+                    attributes: { 'gen_ai.conversation.id': 'conv-xyz789' },
+                },
+                {
+                    timestamp: '2026-01-28T10:02:00Z',
+                    name: 'llm.chat',
+                    attributes: { 'gen_ai.conversation.id': 'conv-abc123' },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({ conversationId: 'conv-abc123' });
+            assert.strictEqual(results.length, 2);
+        });
+        it('should combine OTel GenAI filters with other filters', async () => {
+            const today = getTestDate();
+            const mockEvents = [
+                {
+                    timestamp: '2026-01-28T10:00:00Z',
+                    name: 'llm.chat',
+                    attributes: {
+                        'gen_ai.operation.name': 'chat',
+                        'gen_ai.conversation.id': 'conv-abc123',
+                        'gen_ai.request.model': 'claude-3-opus',
+                    },
+                },
+                {
+                    timestamp: '2026-01-28T10:01:00Z',
+                    name: 'llm.chat',
+                    attributes: {
+                        'gen_ai.operation.name': 'chat',
+                        'gen_ai.conversation.id': 'conv-abc123',
+                        'gen_ai.request.model': 'gpt-4',
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `llm-events-${today}.jsonl`), mockEvents);
+            const results = await backend.queryLLMEvents({
+                operationName: 'chat',
+                conversationId: 'conv-abc123',
+                model: 'claude-3-opus',
+            });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes['gen_ai.request.model'], 'claude-3-opus');
+        });
+    });
+    describe('queryTraces OTel GenAI agent/tool filters', () => {
+        it('should filter traces by agentId', async () => {
+            const today = getTestDate();
+            const mockSpans = [
+                {
+                    traceId: 'trace1',
+                    spanId: 'span1',
+                    name: 'agent.invoke',
+                    startTime: [1700000000, 0],
+                    attributes: { 'gen_ai.agent.id': 'agent-001' },
+                },
+                {
+                    traceId: 'trace1',
+                    spanId: 'span2',
+                    name: 'agent.invoke',
+                    startTime: [1700000001, 0],
+                    attributes: { 'gen_ai.agent.id': 'agent-002' },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
+            const results = await backend.queryTraces({ agentId: 'agent-001' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.agent.id'], 'agent-001');
+        });
+        it('should filter traces by agentName', async () => {
+            const today = getTestDate();
+            const mockSpans = [
+                {
+                    traceId: 'trace1',
+                    spanId: 'span1',
+                    name: 'agent.invoke',
+                    startTime: [1700000000, 0],
+                    attributes: { 'gen_ai.agent.name': 'Explore' },
+                },
+                {
+                    traceId: 'trace1',
+                    spanId: 'span2',
+                    name: 'agent.invoke',
+                    startTime: [1700000001, 0],
+                    attributes: { 'gen_ai.agent.name': 'Plan' },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
+            const results = await backend.queryTraces({ agentName: 'Explore' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.agent.name'], 'Explore');
+        });
+        it('should filter traces by toolName', async () => {
+            const today = getTestDate();
+            const mockSpans = [
+                {
+                    traceId: 'trace1',
+                    spanId: 'span1',
+                    name: 'tool.execute',
+                    startTime: [1700000000, 0],
+                    attributes: { 'gen_ai.tool.name': 'Read' },
+                },
+                {
+                    traceId: 'trace1',
+                    spanId: 'span2',
+                    name: 'tool.execute',
+                    startTime: [1700000001, 0],
+                    attributes: { 'gen_ai.tool.name': 'Write' },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
+            const results = await backend.queryTraces({ toolName: 'Read' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.tool.name'], 'Read');
+        });
+        it('should filter traces by toolCallId', async () => {
+            const today = getTestDate();
+            const mockSpans = [
+                {
+                    traceId: 'trace1',
+                    spanId: 'span1',
+                    name: 'tool.execute',
+                    startTime: [1700000000, 0],
+                    attributes: { 'gen_ai.tool.call.id': 'toolu_abc123' },
+                },
+                {
+                    traceId: 'trace1',
+                    spanId: 'span2',
+                    name: 'tool.execute',
+                    startTime: [1700000001, 0],
+                    attributes: { 'gen_ai.tool.call.id': 'toolu_xyz789' },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
+            const results = await backend.queryTraces({ toolCallId: 'toolu_abc123' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.tool.call.id'], 'toolu_abc123');
+        });
+        it('should filter traces by toolType', async () => {
+            const today = getTestDate();
+            const mockSpans = [
+                {
+                    traceId: 'trace1',
+                    spanId: 'span1',
+                    name: 'tool.execute',
+                    startTime: [1700000000, 0],
+                    attributes: { 'gen_ai.tool.type': 'function' },
+                },
+                {
+                    traceId: 'trace1',
+                    spanId: 'span2',
+                    name: 'tool.execute',
+                    startTime: [1700000001, 0],
+                    attributes: { 'gen_ai.tool.type': 'mcp' },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
+            const results = await backend.queryTraces({ toolType: 'function' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.tool.type'], 'function');
+        });
+        it('should filter traces by operationName', async () => {
+            const today = getTestDate();
+            const mockSpans = [
+                {
+                    traceId: 'trace1',
+                    spanId: 'span1',
+                    name: 'llm.call',
+                    startTime: [1700000000, 0],
+                    attributes: { 'gen_ai.operation.name': 'chat' },
+                },
+                {
+                    traceId: 'trace1',
+                    spanId: 'span2',
+                    name: 'tool.execute',
+                    startTime: [1700000001, 0],
+                    attributes: { 'gen_ai.operation.name': 'execute_tool' },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
+            const results = await backend.queryTraces({ operationName: 'chat' });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.operation.name'], 'chat');
+        });
+        it('should combine agent/tool filters with other trace filters', async () => {
+            const today = getTestDate();
+            const mockSpans = [
+                {
+                    traceId: 'trace1',
+                    spanId: 'span1',
+                    name: 'agent.explore',
+                    startTime: [1700000000, 0],
+                    duration: [0, 100000000], // 100ms
+                    attributes: {
+                        'gen_ai.agent.name': 'Explore',
+                        'gen_ai.tool.name': 'Grep',
+                    },
+                },
+                {
+                    traceId: 'trace1',
+                    spanId: 'span2',
+                    name: 'agent.explore',
+                    startTime: [1700000001, 0],
+                    duration: [0, 200000000], // 200ms
+                    attributes: {
+                        'gen_ai.agent.name': 'Explore',
+                        'gen_ai.tool.name': 'Read',
+                    },
+                },
+            ];
+            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
+            const results = await backend.queryTraces({
+                agentName: 'Explore',
+                toolName: 'Grep',
+                spanName: 'agent',
+            });
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].attributes?.['gen_ai.tool.name'], 'Grep');
+        });
     });
     describe('healthCheck', () => {
         it('should return error when telemetry directory does not exist', async () => {
@@ -2997,6 +3291,46 @@ describe('QueryCache', () => {
             assert.strictEqual(result2.length, 1, 'Should return cached LLM events result');
         });
     });
+    describe('getCacheStats', () => {
+        it('should return correct cache stats structure', () => {
+            const stats = backend.getCacheStats();
+            assert.ok(stats.traces, 'Should have traces stats');
+            assert.ok(stats.logs, 'Should have logs stats');
+            assert.ok(stats.metrics, 'Should have metrics stats');
+            assert.ok(stats.llmEvents, 'Should have llmEvents stats');
+            // Check structure of each cache stat
+            for (const key of ['traces', 'logs', 'metrics', 'llmEvents']) {
+                const stat = stats[key];
+                assert.strictEqual(typeof stat.hits, 'number', `${key} should have hits`);
+                assert.strictEqual(typeof stat.misses, 'number', `${key} should have misses`);
+                assert.strictEqual(typeof stat.evictions, 'number', `${key} should have evictions`);
+                assert.strictEqual(typeof stat.size, 'number', `${key} should have size`);
+                assert.strictEqual(typeof stat.hitRate, 'number', `${key} should have hitRate`);
+            }
+        });
+        it('should track cache hits and misses', async () => {
+            const today = getTestDate();
+            const mockSpans = [
+                { traceId: 'stats-test-1', spanId: 'span1', name: 'test-op', startTime: [1700000000, 0] },
+            ];
+            writeJsonlFile(path.join(tempDir, `traces-${today}.jsonl`), mockSpans);
+            // Initial stats should be zero
+            let stats = backend.getCacheStats();
+            assert.strictEqual(stats.traces.hits, 0);
+            assert.strictEqual(stats.traces.misses, 0);
+            // First query - cache miss
+            await backend.queryTraces({ spanName: 'test-op' });
+            stats = backend.getCacheStats();
+            assert.strictEqual(stats.traces.misses, 1);
+            assert.strictEqual(stats.traces.hits, 0);
+            // Second query with same options - cache hit
+            await backend.queryTraces({ spanName: 'test-op' });
+            stats = backend.getCacheStats();
+            assert.strictEqual(stats.traces.hits, 1);
+            assert.strictEqual(stats.traces.misses, 1);
+            assert.ok(stats.traces.hitRate > 0, 'Hit rate should be > 0');
+        });
+    });
     describe('indexed queries', () => {
         it('should use index for trace queries when available', async () => {
             const today = getTestDate();
@@ -3367,6 +3701,33 @@ describe('MultiDirectoryBackend', () => {
             assert.ok(health.message?.includes('telemetry director'));
         });
     });
+    describe('getCacheStats', () => {
+        it('should return aggregated cache stats from all backends', () => {
+            const localTelemetry = path.join(projectDir, 'telemetry');
+            fs.mkdirSync(localTelemetry, { recursive: true });
+            const backend = new MultiDirectoryBackend(projectDir);
+            const stats = backend.getCacheStats();
+            assert.ok(stats.traces, 'Should have traces stats');
+            assert.ok(stats.logs, 'Should have logs stats');
+            assert.ok(stats.metrics, 'Should have metrics stats');
+            assert.ok(stats.llmEvents, 'Should have llmEvents stats');
+        });
+        it('should have correct structure for aggregated stats', () => {
+            const localTelemetry = path.join(projectDir, 'telemetry');
+            fs.mkdirSync(localTelemetry, { recursive: true });
+            const backend = new MultiDirectoryBackend(projectDir);
+            const stats = backend.getCacheStats();
+            for (const key of ['traces', 'logs', 'metrics', 'llmEvents']) {
+                const stat = stats[key];
+                assert.strictEqual(typeof stat.hits, 'number', `${key} should have hits`);
+                assert.strictEqual(typeof stat.misses, 'number', `${key} should have misses`);
+                assert.strictEqual(typeof stat.evictions, 'number', `${key} should have evictions`);
+                assert.strictEqual(typeof stat.size, 'number', `${key} should have size`);
+                assert.strictEqual(typeof stat.hitRate, 'number', `${key} should have hitRate`);
+                assert.ok(stat.hitRate >= 0 && stat.hitRate <= 1, `${key} hitRate should be between 0 and 1`);
+            }
+        });
+    });
 });
 /**
  * OTLP Export Tests