observability-toolkit 1.1.0 → 1.3.0

package/dist/tools/query-logs.test.js

@@ -0,0 +1,668 @@
+/**
+ * Unit tests for query-logs tool
+ */
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { queryLogs, queryLogsSchema, queryLogsTool } from './query-logs.js';
+// Mock data storage
+let mockLocalLogs = [];
+let mockSignozLogs = [];
+// Create mock backends using the TelemetryBackend interface
+function createMockLocalBackend() {
+    return {
+        name: 'mock-local',
+        queryLogs: async () => mockLocalLogs,
+        queryTraces: async () => [],
+        queryMetrics: async () => [],
+        healthCheck: async () => ({ status: 'ok' }),
+    };
+}
+function createMockSignozBackend() {
+    return {
+        name: 'mock-signoz',
+        queryLogs: async () => mockSignozLogs,
+        queryTraces: async () => [],
+        queryMetrics: async () => [],
+        healthCheck: async () => ({ status: 'ok' }),
+    };
+}
+// Options with mock backends
+function getMockOptions() {
+    return {
+        localBackend: createMockLocalBackend(),
+        signozBackend: createMockSignozBackend(),
+    };
+}
+// Store original env values
+const originalEnv = {
+    SIGNOZ_URL: process.env.SIGNOZ_URL,
+    SIGNOZ_API_KEY: process.env.SIGNOZ_API_KEY,
+};
+describe('query-logs tool', () => {
+    // Test the schema validation
+    describe('queryLogsSchema', () => {
+        it('should validate input with backend=local', () => {
+            const result = queryLogsSchema.parse({ backend: 'local' });
+            assert.deepStrictEqual(result.backend, 'local');
+        });
+        it('should validate input with backend=signoz', () => {
+            const result = queryLogsSchema.parse({ backend: 'signoz' });
+            assert.deepStrictEqual(result.backend, 'signoz');
+        });
+        it('should validate input with backend=auto', () => {
+            const result = queryLogsSchema.parse({ backend: 'auto' });
+            assert.deepStrictEqual(result.backend, 'auto');
+        });
+        it('should default backend to auto when not provided', () => {
+            const result = queryLogsSchema.parse({});
+            assert.deepStrictEqual(result.backend, 'auto');
+        });
+        it('should reject invalid backend values', () => {
+            assert.throws(() => queryLogsSchema.parse({ backend: 'invalid' }), { name: 'ZodError' });
+        });
+        it('should validate optional severity field', () => {
+            const result = queryLogsSchema.parse({ severity: 'ERROR' });
+            assert.deepStrictEqual(result.severity, 'ERROR');
+        });
+        it('should validate optional search field', () => {
+            const result = queryLogsSchema.parse({ search: 'error message' });
+            assert.deepStrictEqual(result.search, 'error message');
+        });
+        it('should validate optional traceId field', () => {
+            const result = queryLogsSchema.parse({ traceId: 'abc123' });
+            assert.deepStrictEqual(result.traceId, 'abc123');
+        });
+        it('should validate optional startDate field', () => {
+            const result = queryLogsSchema.parse({ startDate: '2026-01-01' });
+            assert.deepStrictEqual(result.startDate, '2026-01-01');
+        });
+        it('should validate optional endDate field', () => {
+            const result = queryLogsSchema.parse({ endDate: '2026-01-31' });
+            assert.deepStrictEqual(result.endDate, '2026-01-31');
+        });
+        it('should validate limit field with default of 50', () => {
+            const result = queryLogsSchema.parse({});
+            assert.deepStrictEqual(result.limit, 50);
+        });
+        it('should accept custom limit value', () => {
+            const result = queryLogsSchema.parse({ limit: 100 });
+            assert.deepStrictEqual(result.limit, 100);
+        });
+        it('should reject non-numeric limit', () => {
+            assert.throws(() => queryLogsSchema.parse({ limit: 'fifty' }), { name: 'ZodError' });
+        });
+        it('should validate multiple fields together', () => {
+            const result = queryLogsSchema.parse({
+                backend: 'local',
+                severity: 'WARN',
+                search: 'test',
+                traceId: 'trace-123',
+                startDate: '2026-01-01',
+                endDate: '2026-01-31',
+                limit: 25,
+            });
+            assert.deepStrictEqual(result.backend, 'local');
+            assert.deepStrictEqual(result.severity, 'WARN');
+            assert.deepStrictEqual(result.search, 'test');
+            assert.deepStrictEqual(result.traceId, 'trace-123');
+            assert.deepStrictEqual(result.startDate, '2026-01-01');
+            assert.deepStrictEqual(result.endDate, '2026-01-31');
+            assert.deepStrictEqual(result.limit, 25);
+        });
+    });
+    // Test query logs handler function
+    describe('queryLogs handler', () => {
+        // Reset state before each test
+        beforeEach(() => {
+            mockLocalLogs = [];
+            mockSignozLogs = [];
+            // Clear environment variables
+            process.env.SIGNOZ_URL = '';
+            process.env.SIGNOZ_API_KEY = '';
+        });
+        afterEach(() => {
+            // Restore original environment
+            process.env.SIGNOZ_URL = originalEnv.SIGNOZ_URL;
+            process.env.SIGNOZ_API_KEY = originalEnv.SIGNOZ_API_KEY;
+        });
+        it('should query local backend when backend=local', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Test error message',
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.strictEqual(result.backend, 'local');
+            assert.strictEqual(result.count, 1);
+            assert.ok(Array.isArray(result.logs));
+        });
+        it('should include severity filtering in options', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Error message',
+                },
+                {
+                    timestamp: '2026-01-28T12:01:00Z',
+                    severity: 'INFO',
+                    body: 'Info message',
+                },
+            ];
+            const result = await queryLogs({
+                backend: 'local',
+                severity: 'ERROR',
+            }, getMockOptions());
+            assert.ok(result);
+            assert.strictEqual(typeof result.count, 'number');
+        });
+        it('should include search text filtering in options', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Database connection failed',
+                },
+            ];
+            const result = await queryLogs({
+                backend: 'local',
+                search: 'connection',
+            }, getMockOptions());
+            assert.ok(result);
+            assert.strictEqual(typeof result.count, 'number');
+        });
+        it('should include traceId filtering in options', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Error in span',
+                    traceId: 'trace-123',
+                },
+            ];
+            const result = await queryLogs({
+                backend: 'local',
+                traceId: 'trace-123',
+            }, getMockOptions());
+            assert.ok(result);
+            assert.strictEqual(typeof result.count, 'number');
+        });
+        it('should include date range filtering in options', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-15T12:00:00Z',
+                    severity: 'INFO',
+                    body: 'Message 1',
+                },
+            ];
+            const result = await queryLogs({
+                backend: 'local',
+                startDate: '2026-01-01',
+                endDate: '2026-01-31',
+            }, getMockOptions());
+            assert.ok(result);
+            assert.strictEqual(typeof result.count, 'number');
+        });
+        it('should respect limit parameter', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'INFO',
+                    body: 'Message 1',
+                },
+                {
+                    timestamp: '2026-01-28T12:01:00Z',
+                    severity: 'INFO',
+                    body: 'Message 2',
+                },
+            ];
+            const result = await queryLogs({
+                backend: 'local',
+                limit: 1,
+            }, getMockOptions());
+            assert.ok(result);
+            assert.strictEqual(typeof result.count, 'number');
+        });
+        it('should return result with backend, count, and logs', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'INFO',
+                    body: 'Test log',
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result.backend);
+            assert.ok(typeof result.count === 'number');
+            assert.ok(Array.isArray(result.logs));
+        });
+        it('should group logs by severity', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Error 1',
+                },
+                {
+                    timestamp: '2026-01-28T12:01:00Z',
+                    severity: 'ERROR',
+                    body: 'Error 2',
+                },
+                {
+                    timestamp: '2026-01-28T12:02:00Z',
+                    severity: 'INFO',
+                    body: 'Info message',
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result.bySeverity);
+            assert.strictEqual(typeof result.bySeverity, 'object');
+            assert.ok(Object.keys(result.bySeverity).length > 0);
+        });
+        it('should correctly count logs per severity', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Error 1',
+                },
+                {
+                    timestamp: '2026-01-28T12:01:00Z',
+                    severity: 'ERROR',
+                    body: 'Error 2',
+                },
+                {
+                    timestamp: '2026-01-28T12:02:00Z',
+                    severity: 'WARN',
+                    body: 'Warning',
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result.bySeverity);
+            assert.strictEqual(result.bySeverity.ERROR, 2);
+            assert.strictEqual(result.bySeverity.WARN, 1);
+        });
+        it('should truncate long log body to 500 chars', async () => {
+            const longBody = 'x'.repeat(600);
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: longBody,
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result.logs.length > 0);
+            assert.ok(result.logs[0].body.length <= 503); // 500 + '...'
+            assert.ok(result.logs[0].body.endsWith('...'));
+        });
+        it('should not truncate short log body', async () => {
+            const shortBody = 'Short message';
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'INFO',
+                    body: shortBody,
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result.logs.length > 0);
+            assert.strictEqual(result.logs[0].body, shortBody);
+        });
+        it('should preserve log metadata in response', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Test error',
+                    traceId: 'trace-123',
+                    spanId: 'span-456',
+                    attributes: { key: 'value' },
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result.logs.length > 0);
+            const log = result.logs[0];
+            assert.strictEqual(log.timestamp, '2026-01-28T12:00:00Z');
+            assert.strictEqual(log.severity, 'ERROR');
+            assert.strictEqual(log.traceId, 'trace-123');
+            assert.deepStrictEqual(log.attributes, { key: 'value' });
+        });
+        it('should return empty result when no logs match', async () => {
+            mockLocalLogs = [];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.strictEqual(result.backend, 'local');
+            assert.strictEqual(result.count, 0);
+            assert.strictEqual(result.logs.length, 0);
+        });
+    });
+    // Test auto backend selection
+    describe('auto backend selection', () => {
+        beforeEach(() => {
+            mockLocalLogs = [];
+            mockSignozLogs = [];
+            process.env.SIGNOZ_URL = '';
+            process.env.SIGNOZ_API_KEY = '';
+        });
+        afterEach(() => {
+            process.env.SIGNOZ_URL = originalEnv.SIGNOZ_URL;
+            process.env.SIGNOZ_API_KEY = originalEnv.SIGNOZ_API_KEY;
+        });
+        it('should use local backend when signoz not configured', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'INFO',
+                    body: 'Test message',
+                },
+            ];
+            const result = await queryLogs({ backend: 'auto' }, getMockOptions());
+            assert.strictEqual(result.backend, 'local');
+        });
+        it('should use signoz backend when configured and available', async () => {
+            // Note: Constants are read at import time, so we can only test
+            // that the auto backend selection falls back to local when
+            // signoz is not configured via constants
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Local error',
+                },
+            ];
+            const result = await queryLogs({ backend: 'auto' }, getMockOptions());
+            assert.ok(result.backend);
+        });
+        it('should fallback to signoz when local returns empty and signoz configured', async () => {
+            mockLocalLogs = [];
+            mockSignozLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Remote error',
+                },
+            ];
+            const result = await queryLogs({ backend: 'auto' }, getMockOptions());
+            assert.ok(result.backend);
+            assert.ok(typeof result.count === 'number');
+        });
+    });
+    // Test tool export
+    describe('queryLogsTool export', () => {
+        it('should have correct tool name', () => {
+            assert.strictEqual(queryLogsTool.name, 'obs_query_logs');
+        });
+        it('should have description', () => {
+            assert.ok(queryLogsTool.description);
+            assert.strictEqual(typeof queryLogsTool.description, 'string');
+            assert.ok(queryLogsTool.description.length > 0);
+        });
+        it('should have inputSchema', () => {
+            assert.ok(queryLogsTool.inputSchema);
+        });
+        it('should have handler function', () => {
+            assert.strictEqual(typeof queryLogsTool.handler, 'function');
+        });
+        it('should have handler equal to queryLogs function', () => {
+            assert.strictEqual(queryLogsTool.handler, queryLogs);
+        });
+        it('should accept valid input in handler', async () => {
+            mockLocalLogs = [];
+            const result = await queryLogsTool.handler({ backend: 'local' }, getMockOptions());
+            assert.ok(result);
+            assert.ok(result.backend);
+            assert.ok(typeof result.count === 'number');
+        });
+    });
+    // Test error handling and edge cases
+    describe('error handling and edge cases', () => {
+        beforeEach(() => {
+            mockLocalLogs = [];
+            mockSignozLogs = [];
+            process.env.SIGNOZ_URL = '';
+            process.env.SIGNOZ_API_KEY = '';
+        });
+        afterEach(() => {
+            process.env.SIGNOZ_URL = originalEnv.SIGNOZ_URL;
+            process.env.SIGNOZ_API_KEY = originalEnv.SIGNOZ_API_KEY;
+        });
+        it('should handle missing optional parameters', async () => {
+            mockLocalLogs = [];
+            const result = await queryLogs({
+                backend: 'local',
+                // No optional parameters
+            }, getMockOptions());
+            assert.ok(result);
+            assert.strictEqual(result.backend, 'local');
+        });
+        it('should handle combined filters (severity + search + traceId)', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Database connection error',
+                    traceId: 'trace-123',
+                },
+            ];
+            const result = await queryLogs({
+                backend: 'local',
+                severity: 'ERROR',
+                search: 'connection',
+                traceId: 'trace-123',
+            }, getMockOptions());
+            assert.ok(result);
+            assert.strictEqual(typeof result.count, 'number');
+        });
+        it('should handle date range with both start and end dates', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-15T12:00:00Z',
+                    severity: 'INFO',
+                    body: 'Message',
+                },
+            ];
+            const result = await queryLogs({
+                backend: 'local',
+                startDate: '2026-01-01',
+                endDate: '2026-01-31',
+            }, getMockOptions());
+            assert.ok(result);
+        });
+        it('should handle date range with only start date', async () => {
+            mockLocalLogs = [];
+            const result = await queryLogs({
+                backend: 'local',
+                startDate: '2026-01-01',
+            }, getMockOptions());
+            assert.ok(result);
+        });
+        it('should handle date range with only end date', async () => {
+            mockLocalLogs = [];
+            const result = await queryLogs({
+                backend: 'local',
+                endDate: '2026-01-31',
+            }, getMockOptions());
+            assert.ok(result);
+        });
+        it('should handle large limit values', async () => {
+            mockLocalLogs = [];
+            const result = await queryLogs({
+                backend: 'local',
+                limit: 10000,
+            }, getMockOptions());
+            assert.ok(result);
+            assert.strictEqual(typeof result.count, 'number');
+        });
+        it('should handle very small limit values', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'INFO',
+                    body: 'Message',
+                },
+            ];
+            const result = await queryLogs({
+                backend: 'local',
+                limit: 1,
+            }, getMockOptions());
+            assert.ok(result);
+        });
+        it('should handle logs with missing optional fields', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'INFO',
+                    body: 'Message',
+                    // No traceId, spanId, or attributes
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result);
+            assert.ok(result.logs.length > 0);
+        });
+        it('should handle logs with empty attributes', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'INFO',
+                    body: 'Message',
+                    attributes: {},
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result);
+        });
+        it('should handle result with no backend available', async () => {
+            mockLocalLogs = [];
+            mockSignozLogs = [];
+            // Don't configure any backend
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result);
+            assert.strictEqual(typeof result.count, 'number');
+        });
+    });
+    // Test severity filtering variations
+    describe('severity filtering', () => {
+        beforeEach(() => {
+            mockLocalLogs = [];
+            process.env.SIGNOZ_URL = '';
+            process.env.SIGNOZ_API_KEY = '';
+        });
+        afterEach(() => {
+            process.env.SIGNOZ_URL = originalEnv.SIGNOZ_URL;
+            process.env.SIGNOZ_API_KEY = originalEnv.SIGNOZ_API_KEY;
+        });
+        it('should filter by ERROR severity', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Error 1',
+                },
+                {
+                    timestamp: '2026-01-28T12:01:00Z',
+                    severity: 'INFO',
+                    body: 'Info',
+                },
+            ];
+            const result = await queryLogs({
+                backend: 'local',
+                severity: 'ERROR',
+            }, getMockOptions());
+            assert.ok(result);
+        });
+        it('should filter by WARN severity', async () => {
+            const result = await queryLogs({
+                backend: 'local',
+                severity: 'WARN',
+            }, getMockOptions());
+            assert.ok(result);
+        });
+        it('should filter by INFO severity', async () => {
+            const result = await queryLogs({
+                backend: 'local',
+                severity: 'INFO',
+            }, getMockOptions());
+            assert.ok(result);
+        });
+        it('should filter by DEBUG severity', async () => {
+            const result = await queryLogs({
+                backend: 'local',
+                severity: 'DEBUG',
+            }, getMockOptions());
+            assert.ok(result);
+        });
+    });
+    // Test response structure
+    describe('response structure', () => {
+        beforeEach(() => {
+            mockLocalLogs = [];
+            process.env.SIGNOZ_URL = '';
+            process.env.SIGNOZ_API_KEY = '';
+        });
+        afterEach(() => {
+            process.env.SIGNOZ_URL = originalEnv.SIGNOZ_URL;
+            process.env.SIGNOZ_API_KEY = originalEnv.SIGNOZ_API_KEY;
+        });
+        it('should have backend property in response', async () => {
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result.backend);
+        });
+        it('should have count property in response', async () => {
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(typeof result.count === 'number');
+        });
+        it('should have logs array in response', async () => {
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(Array.isArray(result.logs));
+        });
+        it('should have bySeverity object in response', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Error',
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result.bySeverity);
+            assert.strictEqual(typeof result.bySeverity, 'object');
+        });
+        it('should have correct structure for individual log entries', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'ERROR',
+                    body: 'Error message',
+                    traceId: 'trace-123',
+                    attributes: { key: 'value' },
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.ok(result.logs.length > 0);
+            const log = result.logs[0];
+            assert.ok(log.timestamp);
+            assert.ok(log.severity);
+            assert.ok(log.body);
+        });
+        it('should include optional log fields when present', async () => {
+            mockLocalLogs = [
+                {
+                    timestamp: '2026-01-28T12:00:00Z',
+                    severity: 'INFO',
+                    body: 'Message',
+                    traceId: 'trace-123',
+                    spanId: 'span-456',
+                    attributes: { service: 'api' },
+                },
+            ];
+            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            const log = result.logs[0];
+            assert.ok(log.traceId);
+            assert.ok(log.attributes);
+        });
+    });
+});
+//# sourceMappingURL=query-logs.test.js.map