observability-toolkit 1.1.0 → 1.4.0

package/dist/backends/signoz-api.test.js

@@ -0,0 +1,1080 @@
+import { describe, it, mock } from 'node:test';
+import assert from 'node:assert';
+import { SigNozApiBackend } from './signoz-api.js';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const setupMock = (fn) => mock.fn(fn);
+// Helper to create v5 API response format for traces
+function createV5TraceResponse(spans) {
+    return {
+        data: {
+            data: {
+                results: [{
+                        rows: spans.map(s => ({
+                            timestamp: s.timestamp || new Date().toISOString(),
+                            data: {
+                                trace_id: s.traceID || s.trace_id,
+                                span_id: s.spanID || s.span_id,
+                                parent_span_id: s.parentSpanID || s.parent_span_id,
+                                name: s.name,
+                                kind: s.kind,
+                                duration_nano: s.durationNano || s.duration_nano,
+                                'service.name': s.serviceName || s['service.name'],
+                                response_status_code: s.statusCode,
+                            },
+                        })),
+                    }],
+            },
+        },
+    };
+}
+describe('SigNozApiBackend', () => {
+    describe('constructor', () => {
+        it('should initialize with default URL and API key from environment', () => {
+            const backend = new SigNozApiBackend();
+            assert.strictEqual(backend.name, 'signoz-api');
+        });
+        it('should accept custom base URL and API key', () => {
+            const backend = new SigNozApiBackend('https://custom.example.com', 'custom-key');
+            assert.strictEqual(backend.name, 'signoz-api');
+        });
+        it('should strip trailing slashes from base URL', () => {
+            const backend = new SigNozApiBackend('https://example.com/', 'test-key');
+            const url = backend.getTraceUrl('trace-123');
+            assert.strictEqual(url.includes('//trace'), false);
+        });
+        it('should handle multiple trailing slashes', () => {
+            const backend = new SigNozApiBackend('https://example.com///', 'test-key');
+            const url = backend.getTraceUrl('trace-123');
+            assert.strictEqual(url.includes('//trace'), false);
+        });
+    });
+    describe('queryTraces', () => {
+        it('should query traces with basic options using v5 API', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: true,
+                json: async () => createV5TraceResponse([
+                    {
+                        traceID: 'trace-123',
+                        spanID: 'span-456',
+                        name: 'http-request',
+                        timestamp: 1000000000,
+                        durationNano: 500000000,
+                        serviceName: 'api-service',
+                    },
+                ]),
+                text: async () => '',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const traces = await backend.queryTraces({
+                startDate: '2026-01-01',
+                endDate: '2026-01-02',
+                limit: 50,
+            });
+            assert.strictEqual(traces.length, 1);
+            assert.strictEqual(traces[0].traceId, 'trace-123');
+            assert.strictEqual(traces[0].spanId, 'span-456');
+            assert.strictEqual(traces[0].name, 'http-request');
+            assert.strictEqual(traces[0].durationMs, 500);
+        });
+        it('should build filter expression for traceId', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryTraces({ traceId: 'trace-abc' });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const filter = spec.filter;
+            assert.ok(filter.expression.includes("traceID = 'trace-abc'"));
+        });
+        it('should build filter expression for serviceName', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryTraces({ serviceName: 'my-service' });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const filter = spec.filter;
+            assert.ok(filter.expression.includes("serviceName = 'my-service'"));
+        });
+        it('should build filter expression for spanName with LIKE operator', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryTraces({ spanName: 'request' });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const filter = spec.filter;
+            assert.ok(filter.expression.includes("name LIKE '%request%'"));
+        });
+        it('should build filter expression for minDurationMs', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryTraces({ minDurationMs: 100 });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const filter = spec.filter;
+            assert.ok(filter.expression.includes('durationNano >= 100000000'));
+        });
+        it('should build filter expression for maxDurationMs', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryTraces({ maxDurationMs: 500 });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const filter = spec.filter;
+            assert.ok(filter.expression.includes('durationNano <= 500000000'));
+        });
+        it('should combine multiple filters with AND', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryTraces({
+                serviceName: 'api',
+                spanName: 'request',
+                minDurationMs: 50,
+            });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const filter = spec.filter;
+            // Should have 3 conditions joined by AND
+            const andCount = (filter.expression.match(/ AND /g) || []).length;
+            assert.strictEqual(andCount, 2);
+        });
+        it('should map trace span kinds correctly', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: true,
+                json: async () => createV5TraceResponse([
+                    { traceID: 't1', spanID: 's1', name: 'op1', timestamp: 1000, durationNano: 500000, kind: 0 },
+                    { traceID: 't2', spanID: 's2', name: 'op2', timestamp: 1000, durationNano: 500000, kind: 1 },
+                    { traceID: 't3', spanID: 's3', name: 'op3', timestamp: 1000, durationNano: 500000, kind: 2 },
+                    { traceID: 't4', spanID: 's4', name: 'op4', timestamp: 1000, durationNano: 500000, kind: 3 },
+                    { traceID: 't5', spanID: 's5', name: 'op5', timestamp: 1000, durationNano: 500000, kind: 4 },
+                ]),
+                text: async () => '',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const traces = await backend.queryTraces({});
+            assert.strictEqual(traces[0].kind, 'INTERNAL');
+            assert.strictEqual(traces[1].kind, 'SERVER');
+            assert.strictEqual(traces[2].kind, 'CLIENT');
+            assert.strictEqual(traces[3].kind, 'PRODUCER');
+            assert.strictEqual(traces[4].kind, 'CONSUMER');
+        });
+        it('should handle missing kind field', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: true,
+                json: async () => createV5TraceResponse([
+                    { traceID: 't1', spanID: 's1', name: 'op1', timestamp: 1000, durationNano: 500000 },
+                ]),
+                text: async () => '',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const traces = await backend.queryTraces({});
+            assert.strictEqual(traces[0].kind, undefined);
+        });
+        it('should set authentication header correctly', async () => {
+            let capturedHeaders;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                capturedHeaders = options?.headers;
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'my-secret-key');
+            await backend.queryTraces({});
+            assert.strictEqual(capturedHeaders?.['SIGNOZ-API-KEY'], 'my-secret-key');
+        });
+        it('should set Content-Type header', async () => {
+            let capturedHeaders;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                capturedHeaders = options?.headers;
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryTraces({});
+            assert.strictEqual(capturedHeaders?.['Content-Type'], 'application/json');
+        });
+        it('should handle API error responses', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: false,
+                status: 401,
+                text: async () => 'Unauthorized',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'invalid-key');
+            try {
+                await backend.queryTraces({});
+                assert.fail('Should have thrown an error');
+            }
+            catch (error) {
+                assert(error instanceof Error);
+                assert(error.message.includes('401'));
+                // Note: detailed error text is sanitized for security (not leaked to client)
+                assert(error.message.includes('Request failed'));
+            }
+        });
+        it('should return empty array on circuit breaker error', async () => {
+            globalThis.fetch = setupMock(async () => {
+                throw new Error('Circuit breaker open - SigNoz API unavailable');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const traces = await backend.queryTraces({});
+            assert.strictEqual(traces.length, 0);
+        });
+        it('should POST to v5 query_range endpoint', async () => {
+            let capturedUrl = '';
+            globalThis.fetch = setupMock(async (url) => {
+                capturedUrl = String(url);
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryTraces({});
+            assert.ok(capturedUrl.includes('/api/v5/query_range'));
+        });
+        it('should use millisecond timestamps in request', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryTraces({ startDate: '2026-01-01' });
+            const body = capturedBody;
+            // Check that start/end are numbers (milliseconds) not strings (nanoseconds)
+            assert.strictEqual(typeof body.start, 'number');
+            assert.strictEqual(typeof body.end, 'number');
+        });
+        it('should use compositeQuery with builder_query type', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryTraces({});
+            const body = capturedBody;
+            const compositeQuery = body.compositeQuery;
+            const queries = compositeQuery.queries;
+            assert.strictEqual(queries[0].type, 'builder_query');
+            assert.strictEqual(queries[0].spec.signal, 'traces');
+        });
+    });
+    describe('queryLogs', () => {
+        // Helper to create v5 API log response format
+        function createV5LogResponse(logs) {
+            return {
+                data: {
+                    data: {
+                        results: [{
+                                rows: logs.map(l => ({
+                                    timestamp: l.timestamp || new Date().toISOString(),
+                                    data: l,
+                                })),
+                            }],
+                    },
+                },
+            };
+        }
+        it('should query logs with basic options', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: true,
+                json: async () => ({
+                    data: {
+                        data: {
+                            results: [{
+                                    rows: [{
+                                            timestamp: '2026-01-01T12:00:00Z',
+                                            data: {
+                                                severity_text: 'ERROR',
+                                                body: 'An error occurred',
+                                                trace_id: 'trace-123',
+                                                span_id: 'span-456',
+                                            },
+                                        }],
+                                }],
+                        },
+                    },
+                }),
+                text: async () => '',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const logs = await backend.queryLogs({ startDate: '2026-01-01', limit: 50 });
+            assert.strictEqual(logs.length, 1);
+            assert.strictEqual(logs[0].timestamp, '2026-01-01T12:00:00Z');
+            assert.strictEqual(logs[0].severity, 'ERROR');
+            assert.strictEqual(logs[0].body, 'An error occurred');
+            assert.strictEqual(logs[0].traceId, 'trace-123');
+        });
+        it('should build severity filter expression', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5LogResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryLogs({ severity: 'error' });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const filter = spec.filter;
+            assert.ok(filter.expression.includes("severity_text = 'ERROR'"));
+        });
+        it('should build traceId filter expression', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5LogResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryLogs({ traceId: 'trace-xyz' });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const filter = spec.filter;
+            assert.ok(filter.expression.includes("trace_id = 'trace-xyz'"));
+        });
+        it('should build search filter with LIKE operator', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5LogResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryLogs({ search: 'database error' });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const filter = spec.filter;
+            assert.ok(filter.expression.includes("body LIKE '%database error%'"));
+        });
+        it('should combine multiple log filters with AND', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5LogResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryLogs({
+                severity: 'warn',
+                traceId: 'trace-abc',
+                search: 'timeout',
+            });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const filter = spec.filter;
+            // Should have 3 conditions joined by AND
+            const andCount = (filter.expression.match(/ AND /g) || []).length;
+            assert.strictEqual(andCount, 2);
+        });
+        it('should provide default values for missing log fields', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: true,
+                json: async () => ({
+                    data: {
+                        data: {
+                            results: [{
+                                    rows: [{
+                                            timestamp: '2026-01-01T12:00:00Z',
+                                            data: {},
+                                        }],
+                                }],
+                        },
+                    },
+                }),
+                text: async () => '',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const logs = await backend.queryLogs({});
+            assert.strictEqual(logs[0].severity, 'INFO');
+            assert.strictEqual(logs[0].body, '');
+        });
+        it('should handle log API errors', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: false,
+                status: 500,
+                text: async () => 'Internal server error',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            try {
+                await backend.queryLogs({});
+                assert.fail('Should have thrown an error');
+            }
+            catch (error) {
+                assert(error instanceof Error);
+                assert(error.message.includes('500'));
+            }
+        });
+        it('should return empty array on log circuit breaker error', async () => {
+            globalThis.fetch = setupMock(async () => {
+                throw new Error('Circuit breaker open - SigNoz API unavailable');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const logs = await backend.queryLogs({});
+            assert.strictEqual(logs.length, 0);
+        });
+    });
+    describe('queryMetrics', () => {
+        // Helper to create v5 API metric response format
+        function createV5MetricResponse(series) {
+            return {
+                data: {
+                    data: {
+                        results: [{
+                                aggregations: [{
+                                        series: series,
+                                    }],
+                            }],
+                    },
+                },
+            };
+        }
+        it('should query metrics with required metricName', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: true,
+                json: async () => createV5MetricResponse([
+                    {
+                        labels: { service: 'api' },
+                        values: [
+                            { timestamp: 1704110400000, value: 42.5 }, // milliseconds
+                            { timestamp: 1704110460000, value: 43.2 },
+                        ],
+                    },
+                ]),
+                text: async () => '',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const metrics = await backend.queryMetrics({
+                metricName: 'http_requests_total',
+                startDate: '2026-01-01',
+            });
+            assert.strictEqual(metrics.length, 2);
+            assert.strictEqual(metrics[0].name, 'http_requests_total');
+            assert.strictEqual(metrics[0].value, 42.5);
+            assert.strictEqual(metrics[0].attributes?.service, 'api');
+        });
+        it('should throw error when metricName is missing', async () => {
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            try {
+                await backend.queryMetrics({ startDate: '2026-01-01' });
+                assert.fail('Should have thrown an error');
+            }
+            catch (error) {
+                assert(error instanceof Error);
+                assert(error.message.includes('metricName is required'));
+            }
+        });
+        it('should use default aggregation when not specified', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => ({ data: { data: { results: [] } } }),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryMetrics({ metricName: 'test_metric' });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const aggregations = spec.aggregations;
+            // Default uses 'sum' for spaceAggregation
+            assert.strictEqual(aggregations[0].spaceAggregation, 'sum');
+        });
+        it('should use custom aggregation operator', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => ({ data: { data: { results: [] } } }),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryMetrics({ metricName: 'test_metric', aggregation: 'avg' });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const aggregations = spec.aggregations;
+            assert.strictEqual(aggregations[0].spaceAggregation, 'avg');
+        });
+        it('should pass groupBy to query', async () => {
+            let capturedBody;
+            globalThis.fetch = setupMock(async (_url, options) => {
+                if (options?.body) {
+                    capturedBody = JSON.parse(String(options.body));
+                }
+                return {
+                    ok: true,
+                    json: async () => ({ data: { result: [] } }),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            await backend.queryMetrics({
+                metricName: 'test_metric',
+                groupBy: ['service', 'region'],
+            });
+            const body = capturedBody;
+            const query = body.compositeQuery.queries;
+            const spec = query[0].spec;
+            const groupBy = spec.groupBy;
+            assert.strictEqual(groupBy.length, 2);
+            assert.strictEqual(groupBy[0].name, 'service');
+            assert.strictEqual(groupBy[1].name, 'region');
+        });
+        it('should convert timestamps correctly', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: true,
+                json: async () => createV5MetricResponse([
+                    {
+                        values: [{ timestamp: 1704110400000, value: 99 }], // milliseconds
+                    },
+                ]),
+                text: async () => '',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const metrics = await backend.queryMetrics({ metricName: 'test_metric' });
+            // Timestamp 1704110400000 ms = 2024-01-01T12:00:00.000Z
+            assert.strictEqual(metrics[0].timestamp, '2024-01-01T12:00:00.000Z');
+        });
+        it('should respect limit parameter', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: true,
+                json: async () => createV5MetricResponse([
+                    {
+                        values: Array(150)
+                            .fill(0)
+                            .map((_, i) => ({
+                            timestamp: 1704110400000 + i * 60000, // milliseconds
+                            value: i,
+                        })),
+                    },
+                ]),
+                text: async () => '',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const metrics = await backend.queryMetrics({
+                metricName: 'test_metric',
+                limit: 50,
+            });
+            assert.strictEqual(metrics.length, 50);
+        });
+        it('should handle metric API errors', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: false,
+                status: 400,
+                text: async () => 'Bad request',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            try {
+                await backend.queryMetrics({ metricName: 'test_metric' });
+                assert.fail('Should have thrown an error');
+            }
+            catch (error) {
+                assert(error instanceof Error);
+                assert(error.message.includes('400'));
+            }
+        });
+        it('should return empty array on metric circuit breaker error', async () => {
+            globalThis.fetch = setupMock(async () => {
+                throw new Error('Circuit breaker open - SigNoz API unavailable');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const metrics = await backend.queryMetrics({ metricName: 'test_metric' });
+            assert.strictEqual(metrics.length, 0);
+        });
+    });
+    describe('healthCheck', () => {
+        it('should return ok status when healthy', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: true,
+                json: async () => ({ status: 'success' }),
+                text: async () => '',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const health = await backend.healthCheck();
+            assert.strictEqual(health.status, 'ok');
+            assert(health.message?.includes('https://signoz.example.com'));
+        });
+        it('should return error status when URL not configured', async () => {
+            const backend = new SigNozApiBackend('', 'test-key');
+            const health = await backend.healthCheck();
+            // Empty URL should result in error status
+            if (health.status === 'error') {
+                assert.strictEqual(health.status, 'error');
+                assert(health.message?.includes('URL not configured'));
+            }
+            else {
+                // When no explicit URL is provided but env vars might be set
+                assert(health.status === 'ok' || health.status === 'error');
+            }
+        });
+        it('should return error status when API key not configured', async () => {
+            const backend = new SigNozApiBackend('https://signoz.example.com', '');
+            const health = await backend.healthCheck();
+            // Empty API key should result in error status
+            if (health.status === 'error') {
+                assert.strictEqual(health.status, 'error');
+                assert(health.message?.includes('API key not configured'));
+            }
+            else {
+                // When no explicit API key is provided but env vars might be set
+                assert(health.status === 'ok' || health.status === 'error');
+            }
+        });
+        it('should handle API errors during health check', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: false,
+                status: 503,
+                text: async () => 'Service unavailable',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const health = await backend.healthCheck();
+            assert.strictEqual(health.status, 'error');
+            assert(health.message?.includes('503'));
+        });
+    });
+    describe('getTraceUrl', () => {
+        it('should construct trace viewer URL correctly', () => {
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const url = backend.getTraceUrl('trace-abc-123');
+            assert.strictEqual(url, 'https://signoz.example.com/trace/trace-abc-123');
+        });
+        it('should append /trace/{traceId} to base URL', () => {
+            const backend = new SigNozApiBackend('https://signoz.example.com/v1/traces', 'test-key');
+            const url = backend.getTraceUrl('trace-123');
+            assert.ok(url.endsWith('/trace/trace-123'));
+        });
+        it('should use base URL as-is for trace URL', () => {
+            const backend = new SigNozApiBackend('https://ingest.signoz.example.com', 'test-key');
+            const url = backend.getTraceUrl('trace-123');
+            // The implementation uses baseUrl directly without transformations
+            assert.strictEqual(url, 'https://ingest.signoz.example.com/trace/trace-123');
+        });
+        it('should preserve port in trace URL', () => {
+            const backend = new SigNozApiBackend('https://signoz.example.com:4318', 'test-key');
+            const url = backend.getTraceUrl('trace-123');
+            assert.strictEqual(url, 'https://signoz.example.com:4318/trace/trace-123');
+        });
+        it('should handle complex base URL', () => {
+            const backend = new SigNozApiBackend('https://ingest.signoz.example.com:4318/v1/traces', 'test-key');
+            const url = backend.getTraceUrl('trace-123');
+            // Uses baseUrl directly
+            assert.strictEqual(url, 'https://ingest.signoz.example.com:4318/v1/traces/trace/trace-123');
+        });
+    });
+    describe('error response handling', () => {
+        it('should throw error with status code (response text sanitized)', async () => {
+            globalThis.fetch = setupMock(async () => ({
+                ok: false,
+                status: 404,
+                text: async () => 'Metric not found',
+            }));
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            try {
+                await backend.queryMetrics({ metricName: 'nonexistent' });
+                assert.fail('Should have thrown an error');
+            }
+            catch (error) {
+                assert(error instanceof Error);
+                assert(error.message.includes('404'));
+                // Note: detailed error text is sanitized for security (not leaked to client)
+                assert(error.message.includes('Request failed'));
+            }
+        });
+        it('should handle fetch network errors', async () => {
+            globalThis.fetch = setupMock(async () => {
+                throw new Error('Network timeout');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            try {
+                await backend.queryTraces({});
+                assert.fail('Should have thrown an error');
+            }
+            catch (error) {
+                assert(error instanceof Error);
+                assert(error.message.includes('Network timeout'));
+            }
+        });
+        it('should not throw on circuit breaker error for traces', async () => {
+            globalThis.fetch = setupMock(async () => {
+                throw new Error('Circuit breaker open - SigNoz API unavailable');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const result = await backend.queryTraces({});
+            assert.deepStrictEqual(result, []);
+        });
+        it('should not throw on circuit breaker error for logs', async () => {
+            globalThis.fetch = setupMock(async () => {
+                throw new Error('Circuit breaker open - SigNoz API unavailable');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const result = await backend.queryLogs({});
+            assert.deepStrictEqual(result, []);
+        });
+        it('should not throw on circuit breaker error for metrics', async () => {
+            globalThis.fetch = setupMock(async () => {
+                throw new Error('Circuit breaker open - SigNoz API unavailable');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            const result = await backend.queryMetrics({ metricName: 'test' });
+            assert.deepStrictEqual(result, []);
+        });
+    });
+    describe('circuit breaker', () => {
+        it('should open circuit after 3 consecutive failures', async () => {
+            let callCount = 0;
+            globalThis.fetch = setupMock(async () => {
+                callCount++;
+                throw new Error('API error');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            // First 3 failures should hit the API (non-circuit-breaker errors are thrown)
+            for (let i = 0; i < 3; i++) {
+                try {
+                    await backend.queryTraces({});
+                }
+                catch {
+                    // expected - API errors are thrown
+                }
+            }
+            assert.strictEqual(callCount, 3);
+            // 4th call should be blocked by circuit breaker (returns [] instead of calling fetch)
+            const prevCount = callCount;
+            const result = await backend.queryTraces({});
+            assert.deepStrictEqual(result, [], 'Should return empty array when circuit open');
+            assert.strictEqual(callCount, prevCount, 'Should not have made another fetch call when circuit open');
+        });
+        it('should allow request in half-open state after reset time', async () => {
+            const originalDateNow = Date.now;
+            let currentTime = 1000000;
+            Date.now = () => currentTime;
+            let callCount = 0;
+            globalThis.fetch = setupMock(async () => {
+                callCount++;
+                throw new Error('API error');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            // Trigger 3 failures to open circuit
+            for (let i = 0; i < 3; i++) {
+                try {
+                    await backend.queryTraces({});
+                }
+                catch {
+                    // expected
+                }
+            }
+            assert.strictEqual(callCount, 3);
+            // Verify circuit is open (returns [] without fetch call)
+            const result = await backend.queryTraces({});
+            assert.deepStrictEqual(result, []);
+            assert.strictEqual(callCount, 3, 'Should not have made fetch call when circuit open');
+            // Advance time past reset period (default 60000ms)
+            currentTime += 61000;
+            // Should allow one request in half-open state
+            try {
+                await backend.queryTraces({});
+            }
+            catch {
+                // expected to fail, but should have made the request
+            }
+            assert.strictEqual(callCount, 4, 'Should have made request in half-open state');
+            Date.now = originalDateNow;
+        });
+        it('should close circuit after successful request in half-open state', async () => {
+            const originalDateNow = Date.now;
+            let currentTime = 1000000;
+            Date.now = () => currentTime;
+            let shouldFail = true;
+            let callCount = 0;
+            globalThis.fetch = setupMock(async () => {
+                callCount++;
+                if (shouldFail) {
+                    throw new Error('API error');
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            // Trigger 3 failures to open circuit
+            for (let i = 0; i < 3; i++) {
+                try {
+                    await backend.queryTraces({});
+                }
+                catch {
+                    // expected
+                }
+            }
+            // Advance time past reset period
+            currentTime += 61000;
+            shouldFail = false;
+            // Successful request in half-open state should close circuit
+            await backend.queryTraces({});
+            assert.strictEqual(callCount, 4);
+            // Circuit should be closed, subsequent requests should work
+            await backend.queryTraces({});
+            assert.strictEqual(callCount, 5);
+            Date.now = originalDateNow;
+        });
+        it('should reopen circuit after failure in half-open state', async () => {
+            const originalDateNow = Date.now;
+            let currentTime = 1000000;
+            Date.now = () => currentTime;
+            let callCount = 0;
+            globalThis.fetch = setupMock(async () => {
+                callCount++;
+                throw new Error('API error');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            // Trigger 3 failures to open circuit
+            for (let i = 0; i < 3; i++) {
+                try {
+                    await backend.queryTraces({});
+                }
+                catch {
+                    // expected
+                }
+            }
+            assert.strictEqual(callCount, 3);
+            // Advance time past reset period
+            currentTime += 61000;
+            // Request in half-open state fails
+            try {
+                await backend.queryTraces({});
+            }
+            catch {
+                // expected
+            }
+            assert.strictEqual(callCount, 4);
+            // Circuit should be open again (failure in half-open reopens it)
+            const result = await backend.queryTraces({});
+            assert.deepStrictEqual(result, []);
+            assert.strictEqual(callCount, 4, 'Should not have made fetch call when circuit reopened');
+            Date.now = originalDateNow;
+        });
+        it('should reset failure count after successful request', async () => {
+            let shouldFail = true;
+            let callCount = 0;
+            globalThis.fetch = setupMock(async () => {
+                callCount++;
+                if (shouldFail) {
+                    throw new Error('API error');
+                }
+                return {
+                    ok: true,
+                    json: async () => createV5TraceResponse([]),
+                    text: async () => '',
+                };
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            // 2 failures (not enough to open circuit)
+            for (let i = 0; i < 2; i++) {
+                try {
+                    await backend.queryTraces({});
+                }
+                catch {
+                    // expected
+                }
+            }
+            assert.strictEqual(callCount, 2);
+            // Successful request should reset failure count
+            shouldFail = false;
+            await backend.queryTraces({});
+            assert.strictEqual(callCount, 3);
+            // 2 more failures should not open circuit (count was reset)
+            shouldFail = true;
+            for (let i = 0; i < 2; i++) {
+                try {
+                    await backend.queryTraces({});
+                }
+                catch {
+                    // expected
+                }
+            }
+            assert.strictEqual(callCount, 5);
+            // Should still be able to make requests (circuit not open)
+            try {
+                await backend.queryTraces({});
+            }
+            catch {
+                // expected to fail but should make the call
+            }
+            assert.strictEqual(callCount, 6, 'Circuit should still be closed');
+        });
+        it('should block all query methods when circuit is open', async () => {
+            let callCount = 0;
+            globalThis.fetch = setupMock(async () => {
+                callCount++;
+                throw new Error('API error');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            // Open the circuit with traces
+            for (let i = 0; i < 3; i++) {
+                try {
+                    await backend.queryTraces({});
+                }
+                catch {
+                    // expected
+                }
+            }
+            assert.strictEqual(callCount, 3);
+            // All methods should be blocked
+            const methods = [
+                () => backend.queryTraces({}),
+                () => backend.queryLogs({}),
+                () => backend.queryMetrics({ metricName: 'test' }),
+            ];
+            for (const method of methods) {
+                const prevCount = callCount;
+                try {
+                    await method();
+                }
+                catch {
+                    // queryTraces and queryLogs return [] on error, queryMetrics might too
+                }
+                // Verify no additional fetch calls were made
+                assert.strictEqual(callCount, prevCount, 'Should not make fetch call when circuit open');
+            }
+        });
+        it('should report circuit breaker state in health check', async () => {
+            let callCount = 0;
+            globalThis.fetch = setupMock(async () => {
+                callCount++;
+                throw new Error('API error');
+            });
+            const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+            // Open the circuit
+            for (let i = 0; i < 3; i++) {
+                try {
+                    await backend.queryTraces({});
+                }
+                catch {
+                    // expected
+                }
+            }
+            // Health check should report circuit breaker status
+            const health = await backend.healthCheck();
+            assert.strictEqual(health.status, 'error');
+            assert(health.message?.includes('Circuit breaker'));
+        });
+    });
+});
+//# sourceMappingURL=signoz-api.test.js.map