observability-toolkit 1.8.5 → 2.1.0

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

@@ -1,831 +0,0 @@
-/**
- * Core SigNoz API backend tests
- * L-STYLE-2: Split from original 2797-line file for maintainability
- *
- * Related test files:
- * - signoz-api-circuit-breaker.test.ts - Circuit breaker tests
- * - signoz-api-rate-limiter.test.ts - Rate limiter tests
- * - signoz-api-ssrf.test.ts - SSRF protection tests
- */
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import { SigNozApiBackend } from './signoz-api.js';
-import { setupMock, createV5TraceResponse, createV5LogResponse, createV5MetricResponse, } from './signoz-api-test-helpers.js';
-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', () => {
-        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', () => {
-        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');
-            // Whitelisted path prefix (/v1/) is preserved for backward compatibility
-            assert.strictEqual(url, 'https://ingest.signoz.example.com:4318/v1/traces/trace/trace-123');
-        });
-        it('should preserve /api/ path prefix', () => {
-            const backend = new SigNozApiBackend('https://signoz.example.com/api/v3', 'test-key');
-            const url = backend.getTraceUrl('trace-123');
-            assert.strictEqual(url, 'https://signoz.example.com/api/v3/trace/trace-123');
-        });
-        it('should preserve /signoz/ path prefix', () => {
-            const backend = new SigNozApiBackend('https://proxy.example.com/signoz/query', 'test-key');
-            const url = backend.getTraceUrl('trace-123');
-            assert.strictEqual(url, 'https://proxy.example.com/signoz/query/trace/trace-123');
-        });
-        it('should preserve /query/ path prefix', () => {
-            const backend = new SigNozApiBackend('https://signoz.example.com/query/service', 'test-key');
-            const url = backend.getTraceUrl('trace-123');
-            assert.strictEqual(url, 'https://signoz.example.com/query/service/trace/trace-123');
-        });
-        it('should strip non-whitelisted path prefixes', () => {
-            const backend = new SigNozApiBackend('https://signoz.example.com/custom/path', 'test-key');
-            const url = backend.getTraceUrl('trace-123');
-            // /custom/ is not whitelisted, so only origin is used
-            assert.strictEqual(url, 'https://signoz.example.com/trace/trace-123');
-        });
-        it('should strip query params from URL for security', () => {
-            const backend = new SigNozApiBackend('https://signoz.example.com/v1/traces?token=secret', 'test-key');
-            const url = backend.getTraceUrl('trace-123');
-            // Query params stripped, path preserved
-            assert.strictEqual(url, 'https://signoz.example.com/v1/traces/trace/trace-123');
-            assert.ok(!url.includes('token'));
-        });
-        it('should strip fragment from URL for security', () => {
-            const backend = new SigNozApiBackend('https://signoz.example.com/api/v3#section', 'test-key');
-            const url = backend.getTraceUrl('trace-123');
-            assert.ok(!url.includes('#'));
-        });
-    });
-    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, []);
-        });
-    });
-    // Circuit breaker tests: see signoz-api-circuit-breaker.test.ts
-    // Rate limiter tests: see signoz-api-rate-limiter.test.ts
-    // SSRF tests: see signoz-api-ssrf.test.ts
-});
-//# sourceMappingURL=signoz-api.test.js.map