observability-toolkit 1.4.0 → 1.6.0

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

@@ -3,6 +3,10 @@ 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 encode cursor (matches internal implementation)
+function encodeCursor(data) {
+    return Buffer.from(JSON.stringify(data)).toString('base64');
+}
 // Helper to create v5 API response format for traces
 function createV5TraceResponse(spans) {
     return {
@@ -1075,6 +1079,419 @@ describe('SigNozApiBackend', () => {
             assert.strictEqual(health.status, 'error');
             assert(health.message?.includes('Circuit breaker'));
         });
+        it('should log warning when circuit breaker opens', async () => {
+            const warnLogs = [];
+            const originalWarn = console.warn;
+            console.warn = (msg) => { warnLogs.push(msg); };
+            globalThis.fetch = setupMock(async () => {
+                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
+                }
+            }
+            console.warn = originalWarn;
+            // Should have logged one warning when circuit opened
+            assert.strictEqual(warnLogs.length, 1);
+            assert(warnLogs[0].includes('[obs-toolkit] Circuit breaker OPENED'));
+            assert(warnLogs[0].includes('3 consecutive failures'));
+            assert(warnLogs[0].includes('was: closed'));
+        });
+        it('should log info when circuit breaker enters half-open state', async () => {
+            const originalDateNow = Date.now;
+            let currentTime = 1000000;
+            Date.now = () => currentTime;
+            const infoLogs = [];
+            const originalInfo = console.info;
+            console.info = (msg) => { infoLogs.push(msg); };
+            globalThis.fetch = setupMock(async () => {
+                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
+                }
+            }
+            // Advance time past reset period (default 60000ms)
+            currentTime += 61000;
+            // Attempt a request which should trigger half-open transition
+            try {
+                await backend.queryTraces({});
+            }
+            catch {
+                // expected to fail
+            }
+            console.info = originalInfo;
+            Date.now = originalDateNow;
+            // Should have logged info when entering half-open state
+            assert(infoLogs.some(log => log.includes('[obs-toolkit] Circuit breaker entering HALF-OPEN state')));
+        });
+        it('should log info when circuit breaker closes after successful request', async () => {
+            const originalDateNow = Date.now;
+            let currentTime = 1000000;
+            Date.now = () => currentTime;
+            const infoLogs = [];
+            const originalInfo = console.info;
+            console.info = (msg) => { infoLogs.push(msg); };
+            let shouldFail = true;
+            globalThis.fetch = setupMock(async () => {
+                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 and log
+            await backend.queryTraces({});
+            console.info = originalInfo;
+            Date.now = originalDateNow;
+            // Should have logged both half-open transition and close
+            assert(infoLogs.some(log => log.includes('[obs-toolkit] Circuit breaker entering HALF-OPEN state')));
+            assert(infoLogs.some(log => log.includes('[obs-toolkit] Circuit breaker CLOSED after successful request')));
+        });
+    });
+    describe('cursor-based pagination', () => {
+        describe('queryTracesPaginated', () => {
+            it('should return paginated results with hasMore=false when fewer results than limit', async () => {
+                globalThis.fetch = setupMock(async () => ({
+                    ok: true,
+                    json: async () => createV5TraceResponse([
+                        { traceID: 't1', spanID: 's1', name: 'op1', timestamp: '2026-01-01T12:00:00Z', durationNano: 100000 },
+                        { traceID: 't2', spanID: 's2', name: 'op2', timestamp: '2026-01-01T12:01:00Z', durationNano: 200000 },
+                    ]),
+                    text: async () => '',
+                }));
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                const result = await backend.queryTracesPaginated({ limit: 10 });
+                assert.strictEqual(result.data.length, 2);
+                assert.strictEqual(result.hasMore, false);
+                assert.strictEqual(result.nextCursor, undefined);
+            });
+            it('should return hasMore=true and nextCursor when more results available', async () => {
+                // Return 3 results when limit is 2 (we request limit+1 to detect hasMore)
+                globalThis.fetch = setupMock(async () => ({
+                    ok: true,
+                    json: async () => createV5TraceResponse([
+                        { traceID: 't1', spanID: 's1', name: 'op1', timestamp: '2026-01-01T12:00:00Z', durationNano: 100000 },
+                        { traceID: 't2', spanID: 's2', name: 'op2', timestamp: '2026-01-01T12:01:00Z', durationNano: 200000 },
+                        { traceID: 't3', spanID: 's3', name: 'op3', timestamp: '2026-01-01T12:02:00Z', durationNano: 300000 },
+                    ]),
+                    text: async () => '',
+                }));
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                const result = await backend.queryTracesPaginated({ limit: 2 });
+                assert.strictEqual(result.data.length, 2);
+                assert.strictEqual(result.hasMore, true);
+                assert.ok(result.nextCursor);
+            });
+            it('should decode cursor and use for pagination', 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 cursor = encodeCursor({ ts: 1704110400000, offset: 50 });
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                await backend.queryTracesPaginated({ cursor, limit: 10 });
+                const body = capturedBody;
+                assert.strictEqual(body.start, 1704110400000);
+                const query = body.compositeQuery.queries;
+                const spec = query[0].spec;
+                assert.strictEqual(spec.offset, 50);
+            });
+            it('should ignore invalid cursor and use default values', 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.queryTracesPaginated({ cursor: 'invalid-cursor', limit: 10 });
+                const body = capturedBody;
+                const query = body.compositeQuery.queries;
+                const spec = query[0].spec;
+                assert.strictEqual(spec.offset, 0);
+            });
+            it('should return empty result 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 result = await backend.queryTracesPaginated({});
+                assert.deepStrictEqual(result.data, []);
+                assert.strictEqual(result.hasMore, false);
+            });
+        });
+        describe('queryLogsPaginated', () => {
+            function createV5LogResponsePaginated(logs) {
+                return {
+                    data: {
+                        data: {
+                            results: [{
+                                    rows: logs.map(l => ({
+                                        timestamp: l.timestamp || new Date().toISOString(),
+                                        data: l,
+                                    })),
+                                }],
+                        },
+                    },
+                };
+            }
+            it('should return paginated log results', async () => {
+                globalThis.fetch = setupMock(async () => ({
+                    ok: true,
+                    json: async () => createV5LogResponsePaginated([
+                        { body: 'log1', severity_text: 'INFO', timestamp: '2026-01-01T12:00:00Z' },
+                        { body: 'log2', severity_text: 'ERROR', timestamp: '2026-01-01T12:01:00Z' },
+                    ]),
+                    text: async () => '',
+                }));
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                const result = await backend.queryLogsPaginated({ limit: 10 });
+                assert.strictEqual(result.data.length, 2);
+                assert.strictEqual(result.hasMore, false);
+            });
+            it('should return hasMore=true when more logs available', async () => {
+                globalThis.fetch = setupMock(async () => ({
+                    ok: true,
+                    json: async () => createV5LogResponsePaginated([
+                        { body: 'log1', severity_text: 'INFO', timestamp: '2026-01-01T12:00:00Z' },
+                        { body: 'log2', severity_text: 'ERROR', timestamp: '2026-01-01T12:01:00Z' },
+                        { body: 'log3', severity_text: 'WARN', timestamp: '2026-01-01T12:02:00Z' },
+                    ]),
+                    text: async () => '',
+                }));
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                const result = await backend.queryLogsPaginated({ limit: 2 });
+                assert.strictEqual(result.data.length, 2);
+                assert.strictEqual(result.hasMore, true);
+                assert.ok(result.nextCursor);
+            });
+            it('should decode cursor for log pagination', async () => {
+                let capturedBody;
+                globalThis.fetch = setupMock(async (_url, options) => {
+                    if (options?.body) {
+                        capturedBody = JSON.parse(String(options.body));
+                    }
+                    return {
+                        ok: true,
+                        json: async () => createV5LogResponsePaginated([]),
+                        text: async () => '',
+                    };
+                });
+                const cursor = encodeCursor({ ts: 1704110400000, offset: 25 });
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                await backend.queryLogsPaginated({ cursor, limit: 10 });
+                const body = capturedBody;
+                assert.strictEqual(body.start, 1704110400000);
+                const query = body.compositeQuery.queries;
+                const spec = query[0].spec;
+                assert.strictEqual(spec.offset, 25);
+            });
+            it('should return empty result 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 result = await backend.queryLogsPaginated({});
+                assert.deepStrictEqual(result.data, []);
+                assert.strictEqual(result.hasMore, false);
+            });
+        });
+        describe('queryMetricsPaginated', () => {
+            function createV5MetricResponsePaginated(series) {
+                return {
+                    data: {
+                        data: {
+                            results: [{
+                                    aggregations: [{
+                                            series: series,
+                                        }],
+                                }],
+                        },
+                    },
+                };
+            }
+            it('should return paginated metric results', async () => {
+                globalThis.fetch = setupMock(async () => ({
+                    ok: true,
+                    json: async () => createV5MetricResponsePaginated([{
+                            values: [
+                                { timestamp: 1704110400000, value: 42.5 },
+                                { timestamp: 1704110460000, value: 43.2 },
+                            ],
+                        }]),
+                    text: async () => '',
+                }));
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                const result = await backend.queryMetricsPaginated({ metricName: 'test_metric', limit: 10 });
+                assert.strictEqual(result.data.length, 2);
+                assert.strictEqual(result.hasMore, false);
+            });
+            it('should return hasMore=true when more metrics available', async () => {
+                globalThis.fetch = setupMock(async () => ({
+                    ok: true,
+                    json: async () => createV5MetricResponsePaginated([{
+                            values: [
+                                { timestamp: 1704110400000, value: 1 },
+                                { timestamp: 1704110460000, value: 2 },
+                                { timestamp: 1704110520000, value: 3 },
+                            ],
+                        }]),
+                    text: async () => '',
+                }));
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                const result = await backend.queryMetricsPaginated({ metricName: 'test_metric', limit: 2 });
+                assert.strictEqual(result.data.length, 2);
+                assert.strictEqual(result.hasMore, true);
+                assert.ok(result.nextCursor);
+            });
+            it('should decode cursor for metric pagination', async () => {
+                let capturedBody;
+                globalThis.fetch = setupMock(async (_url, options) => {
+                    if (options?.body) {
+                        capturedBody = JSON.parse(String(options.body));
+                    }
+                    return {
+                        ok: true,
+                        json: async () => createV5MetricResponsePaginated([]),
+                        text: async () => '',
+                    };
+                });
+                const cursor = encodeCursor({ ts: 1704110400000, offset: 100 });
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                await backend.queryMetricsPaginated({ cursor, metricName: 'test_metric', limit: 10 });
+                const body = capturedBody;
+                assert.strictEqual(body.start, 1704110400000);
+                const query = body.compositeQuery.queries;
+                const spec = query[0].spec;
+                assert.strictEqual(spec.offset, 100);
+            });
+            it('should throw error when metricName missing', async () => {
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                try {
+                    await backend.queryMetricsPaginated({ limit: 10 });
+                    assert.fail('Should have thrown an error');
+                }
+                catch (error) {
+                    assert(error instanceof Error);
+                    assert(error.message.includes('metricName is required'));
+                }
+            });
+            it('should return empty result 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 result = await backend.queryMetricsPaginated({ metricName: 'test_metric' });
+                assert.deepStrictEqual(result.data, []);
+                assert.strictEqual(result.hasMore, false);
+            });
+        });
+        describe('cursor encoding/decoding', () => {
+            it('should produce valid base64 cursor', async () => {
+                globalThis.fetch = setupMock(async () => ({
+                    ok: true,
+                    json: async () => createV5TraceResponse([
+                        { traceID: 't1', spanID: 's1', name: 'op1', timestamp: '2026-01-01T12:00:00Z', durationNano: 100000 },
+                        { traceID: 't2', spanID: 's2', name: 'op2', timestamp: '2026-01-01T12:01:00Z', durationNano: 200000 },
+                        { traceID: 't3', spanID: 's3', name: 'op3', timestamp: '2026-01-01T12:02:00Z', durationNano: 300000 },
+                    ]),
+                    text: async () => '',
+                }));
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                const result = await backend.queryTracesPaginated({ limit: 2 });
+                assert.ok(result.nextCursor);
+                // Verify cursor is valid base64
+                const decoded = Buffer.from(result.nextCursor, 'base64').toString('utf-8');
+                const parsed = JSON.parse(decoded);
+                assert.strictEqual(typeof parsed.ts, 'number');
+                assert.strictEqual(typeof parsed.offset, 'number');
+            });
+            it('should handle cursor with malformed JSON gracefully', 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 () => '',
+                    };
+                });
+                // Create a base64 string that isn't valid JSON
+                const badCursor = Buffer.from('not valid json').toString('base64');
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                await backend.queryTracesPaginated({ cursor: badCursor, limit: 10 });
+                // Should use default offset
+                const body = capturedBody;
+                const query = body.compositeQuery.queries;
+                const spec = query[0].spec;
+                assert.strictEqual(spec.offset, 0);
+            });
+            it('should handle cursor with wrong types gracefully', 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 () => '',
+                    };
+                });
+                // Create a cursor with wrong types
+                const badCursor = Buffer.from(JSON.stringify({ ts: 'not a number', offset: 'also not' })).toString('base64');
+                const backend = new SigNozApiBackend('https://signoz.example.com', 'test-key');
+                await backend.queryTracesPaginated({ cursor: badCursor, limit: 10 });
+                // Should use default offset
+                const body = capturedBody;
+                const query = body.compositeQuery.queries;
+                const spec = query[0].spec;
+                assert.strictEqual(spec.offset, 0);
+            });
+        });
     });
 });
 //# sourceMappingURL=signoz-api.test.js.map