observability-toolkit 2.0.0 → 2.1.1

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

@@ -1,311 +1,41 @@
 /**
  * Unit tests for query-traces.ts
  */
-import { describe, it, beforeEach, afterEach } from 'node:test';
+import { describe, it, beforeEach } from 'vitest';
 import * as assert from 'node:assert';
+import { MAX_ATTR_KEY_LENGTH, MAX_ATTR_VALUE_LENGTH, MAX_ATTR_FILTERS, } from '../lib/core/shared-schemas.js';
+import { DEFAULT_LIMIT } from '../lib/core/input-validator.js';
+import { ONE_MILLION, } from '../lib/core/units.js';
 import { queryTraces, queryTracesSchema, queryTracesTool } from './query-traces.js';
-import { getMockOptions as getMockBackendOptions } from '../test-helpers/mock-backends.js';
-import { validateBackendSchema, validateLimitSchema, validateDateRangeSchema } from '../test-helpers/schema-validators.js';
+import { getMockOptions as getMockBackendOptions, createCapturingBackend } from '../test-helpers/mock-backends.js';
+import { validateLimitSchema, validateDateRangeSchema } from '../test-helpers/schema-validators.js';
 import { validateToolDefinition } from '../test-helpers/tool-validators.js';
-import { captureEnv, restoreEnv, clearSigNozEnv } from '../test-helpers/env-utils.js';
+// ---------- test constants ----------
+// duration fixture values (ms)
+const DURATION_SHORT_MS = 10;
+const DURATION_STANDARD_MS = 100;
+const DURATION_LONG_MS = 1000;
+// finite number test values
+const POSITIVE_HALF = 0.5;
+const NEGATIVE_HALF = -0.5;
+// injection test
+const INJECTION_REPEAT_COUNT = 30;
 // Mock data storage
-const mockStore = { local: [], signoz: [] };
-// Options with mock backends
+const mockStore = { local: [] };
 function getMockOptions() {
     return getMockBackendOptions(mockStore, 'traces');
 }
-// Capture original env values
-const originalEnv = captureEnv();
 // Pure schema validation (no setup/teardown needed)
-describe('queryTracesSchema (pure validation)', () => {
-    validateBackendSchema(queryTracesSchema, 'queryTracesSchema');
-    validateLimitSchema(queryTracesSchema, 'queryTracesSchema', 50);
+void describe('queryTracesSchema (pure validation)', () => {
+    validateLimitSchema(queryTracesSchema, 'queryTracesSchema', DEFAULT_LIMIT);
     validateDateRangeSchema(queryTracesSchema, 'queryTracesSchema');
 });
-describe('queryTraces', () => {
+void describe('queryTraces', () => {
     beforeEach(() => {
-        // Reset mock data before each test
         mockStore.local = [];
-        mockStore.signoz = [];
     });
-    describe('schema validation', () => {
-        it('should validate valid input', () => {
-            const input = {
-                backend: 'local',
-                traceId: 'trace-123',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-        });
-        it('should accept all optional filter parameters', () => {
-            const input = {
-                backend: 'signoz',
-                traceId: 'trace-123',
-                serviceName: 'my-service',
-                spanName: 'handler',
-                minDurationMs: 10,
-                maxDurationMs: 5000,
-                startDate: '2026-01-01',
-                endDate: '2026-01-31',
-                limit: 100,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-        });
-        it('should reject serviceName exceeding 256 characters', () => {
-            const input = {
-                backend: 'local',
-                serviceName: 'a'.repeat(257),
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, false);
-        });
-        it('should reject spanName exceeding 512 characters', () => {
-            const input = {
-                backend: 'local',
-                spanName: 'a'.repeat(513),
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, false);
-        });
-        it('should reject agentId exceeding 128 characters', () => {
-            const input = {
-                backend: 'local',
-                agentId: 'a'.repeat(129),
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, false);
-        });
-        it('should reject toolName exceeding 256 characters', () => {
-            const input = {
-                backend: 'local',
-                toolName: 'a'.repeat(257),
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, false);
-        });
-        it('should accept strings at maximum allowed length', () => {
-            const input = {
-                backend: 'local',
-                serviceName: 'a'.repeat(256),
-                spanName: 'a'.repeat(512),
-                agentId: 'a'.repeat(128),
-                toolName: 'a'.repeat(256),
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-        });
-    });
-    describe('local backend', () => {
-        it('should query local backend when backend=local', async () => {
-            // We need to test the actual behavior without modifying the source
-            // This test verifies the schema is correct for local backend selection
-            const input = {
-                backend: 'local',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.backend, 'local');
-            }
-        });
-        it('should filter by traceId from local backend', async () => {
-            const input = {
-                backend: 'local',
-                traceId: 'trace-001',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.traceId, 'trace-001');
-            }
-        });
-        it('should filter by serviceName from local backend', async () => {
-            const input = {
-                backend: 'local',
-                serviceName: 'my-service',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.serviceName, 'my-service');
-            }
-        });
-        it('should filter by spanName from local backend', async () => {
-            const input = {
-                backend: 'local',
-                spanName: 'http-request',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.spanName, 'http-request');
-            }
-        });
-        it('should filter by minDurationMs from local backend', async () => {
-            const input = {
-                backend: 'local',
-                minDurationMs: 100,
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.minDurationMs, 100);
-            }
-        });
-        it('should filter by maxDurationMs from local backend', async () => {
-            const input = {
-                backend: 'local',
-                maxDurationMs: 5000,
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.maxDurationMs, 5000);
-            }
-        });
-        it('should filter by date range from local backend', async () => {
-            const input = {
-                backend: 'local',
-                startDate: '2026-01-20',
-                endDate: '2026-01-28',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.startDate, '2026-01-20');
-                assert.strictEqual(result.data.endDate, '2026-01-28');
-            }
-        });
-    });
-    describe('SigNoz backend', () => {
-        it('should accept signoz backend', async () => {
-            const input = {
-                backend: 'signoz',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.backend, 'signoz');
-            }
-        });
-        it('should filter by traceId from SigNoz backend', async () => {
-            const input = {
-                backend: 'signoz',
-                traceId: 'trace-999',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.traceId, 'trace-999');
-            }
-        });
-        it('should filter by serviceName from SigNoz backend', async () => {
-            const input = {
-                backend: 'signoz',
-                serviceName: 'api-service',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.serviceName, 'api-service');
-            }
-        });
-        it('should filter by spanName from SigNoz backend', async () => {
-            const input = {
-                backend: 'signoz',
-                spanName: 'database-query',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.spanName, 'database-query');
-            }
-        });
-        it('should filter by minDurationMs from SigNoz backend', async () => {
-            const input = {
-                backend: 'signoz',
-                minDurationMs: 500,
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.minDurationMs, 500);
-            }
-        });
-        it('should filter by date range from SigNoz backend', async () => {
-            const input = {
-                backend: 'signoz',
-                startDate: '2026-01-15',
-                endDate: '2026-01-28',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.startDate, '2026-01-15');
-                assert.strictEqual(result.data.endDate, '2026-01-28');
-            }
-        });
-    });
-    describe('auto backend selection', () => {
-        beforeEach(() => {
-            mockStore.local = [];
-            mockStore.signoz = [];
-            clearSigNozEnv();
-        });
-        afterEach(() => {
-            restoreEnv(originalEnv);
-        });
-        it('should accept auto backend schema', async () => {
-            const input = {
-                backend: 'auto',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.backend, 'auto');
-            }
-        });
-        it('should be the default backend', async () => {
-            const input = { limit: 50 };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.backend, 'auto');
-            }
-        });
-        it('should use local backend when signoz not configured', async () => {
-            mockStore.local = [
-                {
-                    traceId: 'trace-local-001',
-                    spanId: 'span-001',
-                    name: 'local-operation',
-                    kind: 'INTERNAL',
-                    durationMs: 10,
-                    status: { code: 0 },
-                    attributes: { 'service.name': 'test-service' },
-                },
-            ];
-            const result = await queryTraces({ backend: 'auto' }, getMockOptions());
-            assert.strictEqual(result.backend, 'local');
-            assert.strictEqual(result.count, 1);
-        });
-        it('should return local traces when available', async () => {
+    void describe('local backend', () => {
+        void it('should return local traces when available', async () => {
             mockStore.local = [
                 {
                     traceId: 'trace-local-002',
@@ -317,65 +47,18 @@ describe('queryTraces', () => {
                     attributes: {},
                 },
             ];
-            const result = await queryTraces({ backend: 'auto' }, getMockOptions());
-            assert.strictEqual(result.backend, 'local');
+            const result = await queryTraces({ backend: 'local' }, getMockOptions());
             assert.strictEqual(result.traces.length, 1);
             assert.strictEqual(result.traces[0].traceId, 'trace-local-002');
         });
-        it('should return empty result with local backend when no traces found', async () => {
-            mockStore.local = [];
-            const result = await queryTraces({ backend: 'auto' }, getMockOptions());
-            assert.ok(result.backend);
+        void it('should return empty result when no traces found', async () => {
+            const result = await queryTraces({ backend: 'local' }, getMockOptions());
             assert.strictEqual(result.count, 0);
         });
     });
-    describe('limit parameter', () => {
-        it('should accept custom limit', async () => {
-            const input = {
-                backend: 'local',
-                limit: 100,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.limit, 100);
-            }
-        });
-        it('should accept limit of 1', async () => {
-            const input = {
-                backend: 'local',
-                limit: 1,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.limit, 1);
-            }
-        });
-        it('should accept max limit value of 1000', async () => {
-            const input = {
-                backend: 'local',
-                limit: 1000,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.limit, 1000);
-            }
-        });
-        it('should reject limit values over 1000', async () => {
-            const input = {
-                backend: 'local',
-                limit: 1001,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, false);
-        });
-    });
-    describe('sessionId filter', () => {
-        it('should accept sessionId parameter in schema', () => {
+    void describe('sessionId filter', () => {
+        void it('should accept sessionId parameter in schema', () => {
             const input = {
-                backend: 'local',
                 sessionId: 'session-abc-123',
                 limit: 50,
             };
@@ -385,118 +68,51 @@ describe('queryTraces', () => {
                 assert.strictEqual(result.data.sessionId, 'session-abc-123');
             }
         });
-        it('should merge sessionId into attributeFilter as session.id', async () => {
-            // Create a mock backend that captures the query options
-            let capturedOptions;
-            const capturingBackend = {
-                name: 'capturing-backend',
-                queryTraces: async (options) => {
-                    capturedOptions = options;
-                    return [];
-                },
-                queryLogs: async () => [],
-                queryMetrics: async () => [],
-                healthCheck: async () => ({ status: 'ok' }),
-            };
+        void it('should merge sessionId into attributeFilter as session.id', async () => {
+            const captured = { current: undefined };
+            const capturingBackend = createCapturingBackend(captured);
             await queryTraces({ backend: 'local', sessionId: 'session-xyz-789' }, { localBackend: capturingBackend });
-            assert.ok(capturedOptions);
-            assert.deepStrictEqual(capturedOptions.attributeFilter?.['session.id'], 'session-xyz-789');
+            assert.ok(captured.current);
+            assert.deepStrictEqual(captured.current.attributeFilter?.['session.id'], 'session-xyz-789');
         });
-        it('should merge sessionId with existing attributeFilter', async () => {
-            let capturedOptions;
-            const capturingBackend = {
-                name: 'capturing-backend',
-                queryTraces: async (options) => {
-                    capturedOptions = options;
-                    return [];
-                },
-                queryLogs: async () => [],
-                queryMetrics: async () => [],
-                healthCheck: async () => ({ status: 'ok' }),
-            };
+        void it('should merge sessionId with existing attributeFilter', async () => {
+            const captured = { current: undefined };
+            const capturingBackend = createCapturingBackend(captured);
             await queryTraces({
                 backend: 'local',
                 sessionId: 'session-merge-test',
                 attributeFilter: { 'hook.name': 'session-start' },
             }, { localBackend: capturingBackend });
-            assert.ok(capturedOptions);
-            assert.ok(capturedOptions.attributeFilter);
-            assert.strictEqual(capturedOptions.attributeFilter['session.id'], 'session-merge-test');
-            assert.strictEqual(capturedOptions.attributeFilter['hook.name'], 'session-start');
-        });
-        it('should not add session.id to attributeFilter when sessionId not provided', async () => {
-            let capturedOptions;
-            const capturingBackend = {
-                name: 'capturing-backend',
-                queryTraces: async (options) => {
-                    capturedOptions = options;
-                    return [];
-                },
-                queryLogs: async () => [],
-                queryMetrics: async () => [],
-                healthCheck: async () => ({ status: 'ok' }),
-            };
+            assert.ok(captured.current);
+            assert.ok(captured.current.attributeFilter);
+            assert.strictEqual(captured.current.attributeFilter['session.id'], 'session-merge-test');
+            assert.strictEqual(captured.current.attributeFilter['hook.name'], 'session-start');
+        });
+        void it('should not add session.id to attributeFilter when sessionId not provided', async () => {
+            const captured = { current: undefined };
+            const capturingBackend = createCapturingBackend(captured);
             await queryTraces({ backend: 'local' }, { localBackend: capturingBackend });
-            assert.ok(capturedOptions);
-            assert.strictEqual(capturedOptions.attributeFilter, undefined);
-        });
-        it('should work with signoz backend', async () => {
-            let capturedOptions;
-            const capturingBackend = {
-                name: 'capturing-signoz',
-                queryTraces: async (options) => {
-                    capturedOptions = options;
-                    return [];
-                },
-                queryLogs: async () => [],
-                queryMetrics: async () => [],
-                healthCheck: async () => ({ status: 'ok' }),
-            };
-            await queryTraces({ backend: 'signoz', sessionId: 'signoz-session-456' }, { signozBackend: capturingBackend });
-            assert.ok(capturedOptions);
-            assert.deepStrictEqual(capturedOptions.attributeFilter?.['session.id'], 'signoz-session-456');
+            assert.ok(captured.current);
+            assert.strictEqual(captured.current.attributeFilter, undefined);
         });
     });
-    describe('attribute filter', () => {
-        it('should accept attributeFilter with string values', async () => {
-            const input = {
-                backend: 'local',
-                attributeFilter: { 'hook.name': 'session-start' },
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.deepStrictEqual(result.data.attributeFilter, { 'hook.name': 'session-start' });
-            }
-        });
-        it('should accept attributeFilter with number values', async () => {
-            const input = {
-                backend: 'local',
-                attributeFilter: { 'http.status_code': 200 },
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.deepStrictEqual(result.data.attributeFilter, { 'http.status_code': 200 });
-            }
-        });
-        it('should accept attributeFilter with boolean values', async () => {
-            const input = {
-                backend: 'local',
-                attributeFilter: { 'mcp.success': true },
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.deepStrictEqual(result.data.attributeFilter, { 'mcp.success': true });
+    void describe('attribute filter', () => {
+        void it('should accept attributeFilter with string, number, and boolean values', () => {
+            const cases = [
+                { label: 'string', filter: { 'hook.name': 'session-start' } },
+                { label: 'number', filter: { 'http.status_code': 200 } },
+                { label: 'boolean', filter: { 'mcp.success': true } },
+            ];
+            for (const { label, filter } of cases) {
+                const result = queryTracesSchema.safeParse({ attributeFilter: filter, limit: 50 });
+                assert.strictEqual(result.success, true, `Should accept ${label} value`);
+                if (result.success) {
+                    assert.deepStrictEqual(result.data.attributeFilter, filter);
+                }
             }
         });
-        it('should accept attributeFilter with multiple attributes', async () => {
+        void it('should accept attributeFilter with multiple attributes', () => {
             const input = {
-                backend: 'local',
                 attributeFilter: {
                     'hook.name': 'mcp-pre-tool',
                     'mcp.server': 'signoz',
@@ -512,9 +128,8 @@ describe('queryTraces', () => {
                 assert.strictEqual(result.data.attributeFilter?.['mcp.success'], true);
             }
         });
-        it('should accept attributeFilter combined with other filters', async () => {
+        void it('should accept attributeFilter combined with other filters', () => {
             const input = {
-                backend: 'local',
                 spanName: 'hook',
                 attributeFilter: { 'agent.type': 'Explore' },
                 minDurationMs: 100,
@@ -525,37 +140,14 @@ describe('queryTraces', () => {
             if (result.success) {
                 assert.strictEqual(result.data.spanName, 'hook');
                 assert.deepStrictEqual(result.data.attributeFilter, { 'agent.type': 'Explore' });
-                assert.strictEqual(result.data.minDurationMs, 100);
+                assert.strictEqual(result.data.minDurationMs, DURATION_STANDARD_MS);
             }
         });
-        // Security validation tests for attributeFilter
-        describe('attributeFilter security validation', () => {
-            it('should reject SQL injection in attribute key', () => {
-                const input = {
-                    backend: 'local',
-                    attributeFilter: { "'; DROP TABLE traces; --": 'value' },
-                    limit: 50,
-                };
-                const result = queryTracesSchema.safeParse(input);
-                assert.strictEqual(result.success, false);
-                if (!result.success) {
-                    assert.ok(result.error.message.includes('Invalid attribute name'));
-                }
-            });
-            it('should reject attribute key with spaces', () => {
-                const input = {
-                    backend: 'local',
-                    attributeFilter: { 'attribute with spaces': 'value' },
-                    limit: 50,
-                };
-                const result = queryTracesSchema.safeParse(input);
-                assert.strictEqual(result.success, false);
-            });
-            it('should reject attribute key with special characters', () => {
-                const specialChars = ['@', '#', '$', '%', '^', '&', '*', '(', ')', '-', '+', '=', '[', ']', '{', '}', '|', '\\', '/', ':', ';', '"', "'", '<', '>', ',', '?', '!', '~', '`'];
+        void describe('attributeFilter security validation', () => {
+            void it('should reject attribute key with special characters', () => {
+                const specialChars = ['@', '#', '$', '%', '^', '&', '*', '(', ')', '-', '+', '=', '[', ']', '{', '}', '|', '\\', '/', ':', ';', '"', "'", '<', '>', ',', '?', '!', '~', '`', ' '];
                 for (const char of specialChars) {
                     const input = {
-                        backend: 'local',
                         attributeFilter: { [`attr${char}name`]: 'value' },
                         limit: 50,
                     };
@@ -563,7 +155,7 @@ describe('queryTraces', () => {
                     assert.strictEqual(result.success, false, `Should reject key with '${char}'`);
                 }
             });
-            it('should accept valid attribute key patterns', () => {
+            void it('should accept valid attribute key patterns', () => {
                 const validKeys = [
                     'hook.name',
                     'service_name',
@@ -577,7 +169,6 @@ describe('queryTraces', () => {
                 ];
                 for (const key of validKeys) {
                     const input = {
-                        backend: 'local',
                         attributeFilter: { [key]: 'value' },
                         limit: 50,
                     };
@@ -585,69 +176,31 @@ describe('queryTraces', () => {
                     assert.strictEqual(result.success, true, `Should accept key '${key}'`);
                 }
             });
-            it('should reject attribute key exceeding 100 characters', () => {
-                const longKey = 'a'.repeat(101);
-                const input = {
-                    backend: 'local',
-                    attributeFilter: { [longKey]: 'value' },
-                    limit: 50,
-                };
-                const result = queryTracesSchema.safeParse(input);
-                assert.strictEqual(result.success, false);
-            });
-            it('should accept attribute key at exactly 100 characters', () => {
-                const maxKey = 'a'.repeat(100);
-                const input = {
-                    backend: 'local',
-                    attributeFilter: { [maxKey]: 'value' },
-                    limit: 50,
-                };
-                const result = queryTracesSchema.safeParse(input);
-                assert.strictEqual(result.success, true);
-            });
-            it('should reject string value exceeding 500 characters', () => {
-                const longValue = 'a'.repeat(501);
-                const input = {
-                    backend: 'local',
-                    attributeFilter: { 'valid.key': longValue },
-                    limit: 50,
-                };
-                const result = queryTracesSchema.safeParse(input);
-                assert.strictEqual(result.success, false);
-            });
-            it('should accept string value at exactly 500 characters', () => {
-                const maxValue = 'a'.repeat(500);
-                const input = {
-                    backend: 'local',
-                    attributeFilter: { 'valid.key': maxValue },
-                    limit: 50,
-                };
-                const result = queryTracesSchema.safeParse(input);
-                assert.strictEqual(result.success, true);
+            void it('should enforce max attribute key length boundary', () => {
+                const overKey = 'a'.repeat(MAX_ATTR_KEY_LENGTH + 1);
+                const maxKey = 'a'.repeat(MAX_ATTR_KEY_LENGTH);
+                assert.strictEqual(queryTracesSchema.safeParse({ attributeFilter: { [overKey]: 'value' } }).success, false, 'Should reject key exceeding max length');
+                assert.strictEqual(queryTracesSchema.safeParse({ attributeFilter: { [maxKey]: 'value' } }).success, true, 'Should accept key at max length');
             });
-            it('should reject non-finite number values (Infinity)', () => {
-                const input = {
-                    backend: 'local',
-                    attributeFilter: { 'valid.key': Infinity },
-                    limit: 50,
-                };
-                const result = queryTracesSchema.safeParse(input);
-                assert.strictEqual(result.success, false);
+            void it('should enforce max attribute value length boundary', () => {
+                const overValue = 'a'.repeat(MAX_ATTR_VALUE_LENGTH + 1);
+                const maxValue = 'a'.repeat(MAX_ATTR_VALUE_LENGTH);
+                assert.strictEqual(queryTracesSchema.safeParse({ attributeFilter: { 'valid.key': overValue } }).success, false, 'Should reject value exceeding max length');
+                assert.strictEqual(queryTracesSchema.safeParse({ attributeFilter: { 'valid.key': maxValue } }).success, true, 'Should accept value at max length');
             });
-            it('should reject non-finite number values (NaN)', () => {
-                const input = {
-                    backend: 'local',
-                    attributeFilter: { 'valid.key': NaN },
-                    limit: 50,
-                };
-                const result = queryTracesSchema.safeParse(input);
-                assert.strictEqual(result.success, false);
+            void it('should reject non-finite number values', () => {
+                for (const value of [Infinity, NaN]) {
+                    const result = queryTracesSchema.safeParse({
+                        attributeFilter: { 'valid.key': value },
+                        limit: 50,
+                    });
+                    assert.strictEqual(result.success, false, `Should reject ${value}`);
+                }
             });
-            it('should accept finite number values', () => {
-                const finiteNumbers = [0, 1, -1, 100, 1000000, 0.5, -0.5, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER];
+            void it('should accept finite number values', () => {
+                const finiteNumbers = [0, 1, -1, DURATION_STANDARD_MS, ONE_MILLION, POSITIVE_HALF, NEGATIVE_HALF, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER];
                 for (const num of finiteNumbers) {
                     const input = {
-                        backend: 'local',
                         attributeFilter: { 'valid.key': num },
                         limit: 50,
                     };
@@ -655,13 +208,12 @@ describe('queryTraces', () => {
                     assert.strictEqual(result.success, true, `Should accept number ${num}`);
                 }
             });
-            it('should reject more than 20 attribute filters', () => {
+            void it('should reject more than max attribute filters', () => {
                 const manyFilters = {};
-                for (let i = 0; i < 21; i++) {
+                for (let i = 0; i < MAX_ATTR_FILTERS + 1; i++) {
                     manyFilters[`attr${i}`] = `value${i}`;
                 }
                 const input = {
-                    backend: 'local',
                     attributeFilter: manyFilters,
                     limit: 50,
                 };
@@ -671,78 +223,54 @@ describe('queryTraces', () => {
                     assert.ok(result.error.message.includes('Maximum 20 attribute filters allowed'));
                 }
             });
-            it('should accept exactly 20 attribute filters', () => {
+            void it('should accept exactly max attribute filters', () => {
                 const filters = {};
-                for (let i = 0; i < 20; i++) {
+                for (let i = 0; i < MAX_ATTR_FILTERS; i++) {
                     filters[`attr${i}`] = `value${i}`;
                 }
                 const input = {
-                    backend: 'local',
                     attributeFilter: filters,
                     limit: 50,
                 };
                 const result = queryTracesSchema.safeParse(input);
                 assert.strictEqual(result.success, true);
             });
-            it('should reject SQL injection patterns in attribute values', () => {
-                // Note: String values are allowed to contain SQL-like content,
-                // but they are length-limited. The key restriction provides the primary protection.
-                // This test verifies that long injection attempts are rejected by length limit.
-                const longInjection = "'; DROP TABLE traces; --".repeat(30);
+            void it('should reject SQL injection patterns in attribute values', () => {
+                // Long injection attempts are rejected by length limit
+                const longInjection = "'; DROP TABLE traces; --".repeat(INJECTION_REPEAT_COUNT);
                 const input = {
-                    backend: 'local',
                     attributeFilter: { 'valid.key': longInjection },
                     limit: 50,
                 };
                 const result = queryTracesSchema.safeParse(input);
                 assert.strictEqual(result.success, false);
             });
-            it('should reject XSS patterns in attribute key', () => {
-                const xssPatterns = [
-                    '<script>alert(1)</script>',
-                    'key<img onerror=alert(1)>',
-                    'key"onclick="alert(1)"',
-                ];
-                for (const key of xssPatterns) {
-                    const input = {
-                        backend: 'local',
-                        attributeFilter: { [key]: 'value' },
-                        limit: 50,
-                    };
-                    const result = queryTracesSchema.safeParse(input);
-                    assert.strictEqual(result.success, false, `Should reject XSS key: ${key}`);
-                }
-            });
-            it('should reject empty attribute key', () => {
+            void it('should reject empty attribute key', () => {
                 const input = {
-                    backend: 'local',
                     attributeFilter: { '': 'value' },
                     limit: 50,
                 };
                 const result = queryTracesSchema.safeParse(input);
                 assert.strictEqual(result.success, false);
             });
-            it('should accept empty attributeFilter object', () => {
+            void it('should accept empty attributeFilter object', () => {
                 const input = {
-                    backend: 'local',
                     attributeFilter: {},
                     limit: 50,
                 };
                 const result = queryTracesSchema.safeParse(input);
                 assert.strictEqual(result.success, true);
             });
-            it('should reject attribute key with newlines', () => {
+            void it('should reject attribute key with newlines', () => {
                 const input = {
-                    backend: 'local',
                     attributeFilter: { 'key\nwith\nnewlines': 'value' },
                     limit: 50,
                 };
                 const result = queryTracesSchema.safeParse(input);
                 assert.strictEqual(result.success, false);
             });
-            it('should reject attribute key with tabs', () => {
+            void it('should reject attribute key with tabs', () => {
                 const input = {
-                    backend: 'local',
                     attributeFilter: { 'key\twith\ttabs': 'value' },
                     limit: 50,
                 };
@@ -751,212 +279,53 @@ describe('queryTraces', () => {
             });
         });
     });
-    describe('combined filters', () => {
-        it('should accept multiple filters together', async () => {
-            const input = {
-                backend: 'local',
-                serviceName: 'auth-service',
-                spanName: 'login',
-                minDurationMs: 50,
-                maxDurationMs: 5000,
-                limit: 100,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.serviceName, 'auth-service');
-                assert.strictEqual(result.data.spanName, 'login');
-                assert.strictEqual(result.data.minDurationMs, 50);
-                assert.strictEqual(result.data.maxDurationMs, 5000);
-                assert.strictEqual(result.data.limit, 100);
-            }
-        });
-        it('should accept filters with date range', async () => {
-            const input = {
-                backend: 'signoz',
-                serviceName: 'api',
-                startDate: '2026-01-20',
-                endDate: '2026-01-28',
-                minDurationMs: 10,
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.serviceName, 'api');
-                assert.strictEqual(result.data.startDate, '2026-01-20');
-                assert.strictEqual(result.data.endDate, '2026-01-28');
-            }
-        });
-        it('should accept traceId with other filters', async () => {
-            const input = {
-                backend: 'local',
-                traceId: 'trace-123',
-                spanName: 'operation',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.traceId, 'trace-123');
-                assert.strictEqual(result.data.spanName, 'operation');
-            }
-        });
-    });
     // Use shared tool definition validator
     validateToolDefinition(queryTracesTool, 'obs_query_traces', queryTracesSchema, queryTraces, ['trace']);
-    describe('error handling', () => {
-        it('should accept negative limit (schema does not restrict)', () => {
-            const input = {
-                backend: 'local',
-                limit: -1,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            // Note: Zod number() by default allows negative numbers
-            // This documents current behavior - schema accepts it
-            assert.strictEqual(result.success, true);
-        });
-        it('should accept invalid date format (schema accepts any string)', () => {
-            const input = {
-                backend: 'local',
-                startDate: 'invalid-date',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            // Note: Schema accepts any string, doesn't validate date format
-            // This documents current validation scope
-            assert.strictEqual(result.success, true);
-        });
-    });
-    describe('handler function', () => {
-        it('should be exported', () => {
-            assert.ok(queryTraces);
-            assert.strictEqual(typeof queryTraces, 'function');
-        });
-        it('should accept QueryTracesInput', async () => {
-            const input = {
-                backend: 'local',
-                limit: 50,
-            };
-            // Verify input type is accepted by the function signature
-            assert.ok(input);
-        });
-    });
-    describe('response structure validation', () => {
-        it('should have expected response fields for local backend', () => {
-            // Validate the expected response structure
-            const expectedFields = ['backend', 'count', 'traces'];
-            expectedFields.forEach(field => {
-                assert.ok(typeof field === 'string');
-            });
-        });
-        it('should have trace span fields in response', () => {
-            // Validate expected trace span fields
-            const expectedSpanFields = ['traceId', 'spanId', 'name', 'kind', 'durationMs', 'status', 'attributes'];
-            expectedSpanFields.forEach(field => {
-                assert.ok(typeof field === 'string');
-            });
-        });
-    });
-    describe('input options conversion', () => {
-        it('should convert input to query options correctly', async () => {
+    void describe('input options conversion', () => {
+        void it('should pass all input fields to the backend as query options', async () => {
+            const captured = { current: undefined };
+            const capturingBackend = createCapturingBackend(captured);
             const input = {
                 backend: 'local',
-                traceId: 'trace-123',
+                traceId: 'abc123def456abc123def456abc12345',
                 serviceName: 'service',
                 spanName: 'span',
-                minDurationMs: 10,
-                maxDurationMs: 1000,
+                minDurationMs: DURATION_SHORT_MS,
+                maxDurationMs: DURATION_LONG_MS,
                 startDate: '2026-01-20',
                 endDate: '2026-01-28',
                 limit: 50,
             };
-            // Validate all input fields are present
-            assert.strictEqual(input.traceId, 'trace-123');
-            assert.strictEqual(input.serviceName, 'service');
-            assert.strictEqual(input.spanName, 'span');
-            assert.strictEqual(input.minDurationMs, 10);
-            assert.strictEqual(input.maxDurationMs, 1000);
-            assert.strictEqual(input.startDate, '2026-01-20');
-            assert.strictEqual(input.endDate, '2026-01-28');
-            assert.strictEqual(input.limit, 50);
+            await queryTraces(input, { localBackend: capturingBackend });
+            assert.ok(captured.current);
+            assert.strictEqual(captured.current.traceId, 'abc123def456abc123def456abc12345');
+            assert.strictEqual(captured.current.serviceName, 'service');
+            assert.strictEqual(captured.current.spanName, 'span');
+            assert.strictEqual(captured.current.minDurationMs, DURATION_SHORT_MS);
+            assert.strictEqual(captured.current.maxDurationMs, DURATION_LONG_MS);
+            assert.strictEqual(captured.current.limit, 50);
         });
     });
-    describe('OTel GenAI agent/tool filters', () => {
-        it('should accept agentId filter in schema', () => {
-            const input = {
-                backend: 'local',
-                agentId: 'agent-001',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.agentId, 'agent-001');
-            }
-        });
-        it('should accept agentName filter in schema', () => {
-            const input = {
-                backend: 'local',
-                agentName: 'Explore',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.agentName, 'Explore');
-            }
-        });
-        it('should accept toolName filter in schema', () => {
-            const input = {
-                backend: 'local',
-                toolName: 'Read',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.toolName, 'Read');
-            }
-        });
-        it('should accept toolCallId filter in schema', () => {
-            const input = {
-                backend: 'local',
-                toolCallId: 'toolu_12345',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.toolCallId, 'toolu_12345');
-            }
-        });
-        it('should accept toolType filter in schema', () => {
-            const input = {
-                backend: 'local',
-                toolType: 'function',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.toolType, 'function');
-            }
-        });
-        it('should accept operationName filter in schema', () => {
-            const input = {
-                backend: 'local',
-                operationName: 'invoke_agent',
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.operationName, 'invoke_agent');
+    void describe('OTel GenAI agent/tool filters', () => {
+        void it('should accept agent/tool filter fields in schema', () => {
+            const cases = [
+                { field: 'agentId', value: 'agent-001' },
+                { field: 'agentName', value: 'Explore' },
+                { field: 'toolName', value: 'Read' },
+                { field: 'toolCallId', value: 'toolu_12345' },
+                { field: 'toolType', value: 'function' },
+            ];
+            for (const { field, value } of cases) {
+                const result = queryTracesSchema.safeParse({ [field]: value, limit: 50 });
+                assert.strictEqual(result.success, true, `Should accept ${field}`);
+                if (result.success) {
+                    const data = result.data;
+                    assert.strictEqual(data[field], value);
+                }
             }
         });
-        it('should validate operationName enum values', () => {
-            const validOps = ['chat', 'embeddings', 'invoke_agent', 'execute_tool'];
+        void it('should validate operationName enum values', () => {
+            const validOps = ['chat', 'embeddings', 'invoke_agent', 'execute_tool', 'text_completion', 'generate_content', 'retrieval', 'create_agent', 'invoke_workflow'];
             for (const op of validOps) {
                 const result = queryTracesSchema.safeParse({ operationName: op });
                 assert.strictEqual(result.success, true);
@@ -965,22 +334,13 @@ describe('queryTraces', () => {
                 }
             }
         });
-        it('should reject invalid operationName', () => {
+        void it('should reject invalid operationName', () => {
             const result = queryTracesSchema.safeParse({ operationName: 'invalid' });
             assert.strictEqual(result.success, false);
         });
-        it('should pass agent/tool filters to backend', async () => {
-            let capturedOptions;
-            const capturingBackend = {
-                name: 'capturing-backend',
-                queryTraces: async (options) => {
-                    capturedOptions = options;
-                    return [];
-                },
-                queryLogs: async () => [],
-                queryMetrics: async () => [],
-                healthCheck: async () => ({ status: 'ok' }),
-            };
+        void it('should pass agent/tool filters to backend', async () => {
+            const captured = { current: undefined };
+            const capturingBackend = createCapturingBackend(captured);
             await queryTraces({
                 backend: 'local',
                 agentId: 'agent-abc',
@@ -990,79 +350,13 @@ describe('queryTraces', () => {
                 toolType: 'function',
                 operationName: 'execute_tool',
             }, { localBackend: capturingBackend });
-            assert.ok(capturedOptions);
-            assert.strictEqual(capturedOptions.agentId, 'agent-abc');
-            assert.strictEqual(capturedOptions.agentName, 'Explore');
-            assert.strictEqual(capturedOptions.toolName, 'Grep');
-            assert.strictEqual(capturedOptions.toolCallId, 'call-123');
-            assert.strictEqual(capturedOptions.toolType, 'function');
-            assert.strictEqual(capturedOptions.operationName, 'execute_tool');
-        });
-        it('should combine agent/tool filters with other filters', async () => {
-            const input = {
-                backend: 'local',
-                serviceName: 'claude-code',
-                spanName: 'tool-call',
-                agentId: 'agent-001',
-                toolName: 'Read',
-                minDurationMs: 100,
-                limit: 50,
-            };
-            const result = queryTracesSchema.safeParse(input);
-            assert.strictEqual(result.success, true);
-            if (result.success) {
-                assert.strictEqual(result.data.serviceName, 'claude-code');
-                assert.strictEqual(result.data.spanName, 'tool-call');
-                assert.strictEqual(result.data.agentId, 'agent-001');
-                assert.strictEqual(result.data.toolName, 'Read');
-                assert.strictEqual(result.data.minDurationMs, 100);
-            }
-        });
-    });
-    describe('signoz backend with traces', () => {
-        beforeEach(() => {
-            mockStore.local = [];
-            mockStore.signoz = [];
-        });
-        it('should return traces from signoz backend when backend=signoz', async () => {
-            mockStore.signoz = [
-                {
-                    traceId: 'signoz-trace-001',
-                    spanId: 'signoz-span-001',
-                    name: 'signoz-operation',
-                    kind: 'SERVER',
-                    durationMs: 150,
-                    status: { code: 0 },
-                    attributes: { 'service.name': 'api-service' },
-                },
-                {
-                    traceId: 'signoz-trace-002',
-                    spanId: 'signoz-span-002',
-                    name: 'db-query',
-                    kind: 'CLIENT',
-                    durationMs: 50,
-                    status: { code: 0 },
-                    attributes: { 'db.system': 'postgresql' },
-                },
-            ];
-            const result = await queryTraces({ backend: 'signoz' }, getMockOptions());
-            assert.strictEqual(result.backend, 'signoz');
-            assert.strictEqual(result.count, 2);
-            assert.strictEqual(result.traces.length, 2);
-            assert.strictEqual(result.traces[0].traceId, 'signoz-trace-001');
-            assert.strictEqual(result.traces[0].spanId, 'signoz-span-001');
-            assert.strictEqual(result.traces[0].name, 'signoz-operation');
-            assert.strictEqual(result.traces[0].kind, 'SERVER');
-            assert.strictEqual(result.traces[0].durationMs, 150);
-            assert.deepStrictEqual(result.traces[0].status, { code: 0 });
-            assert.deepStrictEqual(result.traces[0].attributes, { 'service.name': 'api-service' });
-        });
-        it('should return empty traces from signoz backend', async () => {
-            mockStore.signoz = [];
-            const result = await queryTraces({ backend: 'signoz' }, getMockOptions());
-            assert.strictEqual(result.backend, 'signoz');
-            assert.strictEqual(result.count, 0);
-            assert.strictEqual(result.traces.length, 0);
+            assert.ok(captured.current);
+            assert.strictEqual(captured.current.agentId, 'agent-abc');
+            assert.strictEqual(captured.current.agentName, 'Explore');
+            assert.strictEqual(captured.current.toolName, 'Grep');
+            assert.strictEqual(captured.current.toolCallId, 'call-123');
+            assert.strictEqual(captured.current.toolType, 'function');
+            assert.strictEqual(captured.current.operationName, 'execute_tool');
         });
     });
 });