@geekmidas/telescope 10.0.0-alpha.99 → 10.0.0

package/src/__tests__/Telescope.spec.ts

@@ -0,0 +1,438 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { InMemoryStorage } from '../storage/memory';
+import { Telescope } from '../Telescope';
+
+describe('Telescope', () => {
+	let telescope: Telescope;
+	let storage: InMemoryStorage;
+
+	beforeEach(() => {
+		storage = new InMemoryStorage();
+		telescope = new Telescope({ storage });
+	});
+
+	afterEach(() => {
+		telescope.destroy();
+	});
+
+	describe('constructor', () => {
+		it('should create with default options', () => {
+			expect(telescope.enabled).toBe(true);
+			expect(telescope.recordBody).toBe(true);
+		});
+
+		it('should respect enabled option', () => {
+			const disabled = new Telescope({ storage, enabled: false });
+			expect(disabled.enabled).toBe(false);
+			disabled.destroy();
+		});
+
+		it('should respect recordBody option', () => {
+			const noBody = new Telescope({ storage, recordBody: false });
+			expect(noBody.recordBody).toBe(false);
+			noBody.destroy();
+		});
+	});
+
+	describe('recordRequest', () => {
+		it('should record a request and return an ID', async () => {
+			const requestId = await telescope.recordRequest({
+				method: 'GET',
+				path: '/api/users',
+				url: 'http://localhost:3000/api/users',
+				headers: { 'content-type': 'application/json' },
+				query: { page: '1' },
+				status: 200,
+				responseHeaders: { 'content-type': 'application/json' },
+				responseBody: { users: [] },
+				duration: 50,
+			});
+
+			expect(requestId).toBeDefined();
+			expect(typeof requestId).toBe('string');
+
+			const request = await telescope.getRequest(requestId);
+			expect(request).not.toBeNull();
+			expect(request?.method).toBe('GET');
+			expect(request?.path).toBe('/api/users');
+			expect(request?.status).toBe(200);
+		});
+
+		it('should not record when disabled', async () => {
+			const disabled = new Telescope({ storage, enabled: false });
+
+			const requestId = await disabled.recordRequest({
+				method: 'GET',
+				path: '/api/test',
+				url: 'http://localhost/api/test',
+				headers: {},
+				query: {},
+				status: 200,
+				responseHeaders: {},
+				duration: 10,
+			});
+
+			expect(requestId).toBe('');
+
+			const requests = await storage.getRequests();
+			expect(requests).toHaveLength(0);
+
+			disabled.destroy();
+		});
+	});
+
+	describe('logging', () => {
+		it('should record a log entry with info()', async () => {
+			await telescope.info('User logged in', { userId: '123' });
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(1);
+			expect(logs[0].level).toBe('info');
+			expect(logs[0].message).toBe('User logged in');
+			expect(logs[0].context).toEqual({ userId: '123' });
+		});
+
+		it('should record different log levels', async () => {
+			await telescope.debug('Debug message');
+			await telescope.info('Info message');
+			await telescope.warn('Warning message');
+			await telescope.error('Error message');
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(4);
+
+			const levels = logs.map((l) => l.level);
+			expect(levels).toContain('debug');
+			expect(levels).toContain('info');
+			expect(levels).toContain('warn');
+			expect(levels).toContain('error');
+		});
+
+		it('should associate log with request ID', async () => {
+			const requestId = await telescope.recordRequest({
+				method: 'POST',
+				path: '/api/login',
+				url: 'http://localhost/api/login',
+				headers: {},
+				query: {},
+				status: 200,
+				responseHeaders: {},
+				duration: 100,
+			});
+
+			await telescope.info('Login successful', {}, requestId);
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].requestId).toBe(requestId);
+		});
+
+		it('should not record when disabled', async () => {
+			const disabled = new Telescope({ storage, enabled: false });
+
+			await disabled.info('Test message');
+
+			const logs = await storage.getLogs();
+			expect(logs).toHaveLength(0);
+
+			disabled.destroy();
+		});
+
+		it('should batch log entries with log()', async () => {
+			await telescope.log([
+				{ level: 'info', message: 'First' },
+				{ level: 'debug', message: 'Second', context: { step: 2 } },
+				{ level: 'warn', message: 'Third' },
+			]);
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(3);
+		});
+	});
+
+	describe('exception', () => {
+		it('should record an exception with stack trace', async () => {
+			const error = new Error('Something went wrong');
+
+			await telescope.exception(error);
+
+			const exceptions = await telescope.getExceptions();
+			expect(exceptions).toHaveLength(1);
+			expect(exceptions[0].name).toBe('Error');
+			expect(exceptions[0].message).toBe('Something went wrong');
+			expect(exceptions[0].stack.length).toBeGreaterThan(0);
+		});
+
+		it('should associate exception with request ID', async () => {
+			const requestId = await telescope.recordRequest({
+				method: 'GET',
+				path: '/api/error',
+				url: 'http://localhost/api/error',
+				headers: {},
+				query: {},
+				status: 500,
+				responseHeaders: {},
+				duration: 10,
+			});
+
+			await telescope.exception(new Error('Request failed'), requestId);
+
+			const exceptions = await telescope.getExceptions();
+			expect(exceptions[0].requestId).toBe(requestId);
+		});
+	});
+
+	describe('shouldIgnore', () => {
+		it('should ignore paths matching patterns', () => {
+			const withPatterns = new Telescope({
+				storage,
+				ignorePatterns: ['/health', '/metrics', '/__telescope/*'],
+			});
+
+			expect(withPatterns.shouldIgnore('/health')).toBe(true);
+			expect(withPatterns.shouldIgnore('/metrics')).toBe(true);
+			expect(withPatterns.shouldIgnore('/__telescope/api/requests')).toBe(true);
+			expect(withPatterns.shouldIgnore('/api/users')).toBe(false);
+
+			withPatterns.destroy();
+		});
+
+		it('should return false when no patterns configured', () => {
+			expect(telescope.shouldIgnore('/any/path')).toBe(false);
+		});
+	});
+
+	describe('getRequests', () => {
+		it('should return requests with query options', async () => {
+			for (let i = 0; i < 5; i++) {
+				await telescope.recordRequest({
+					method: 'GET',
+					path: `/api/item/${i}`,
+					url: `http://localhost/api/item/${i}`,
+					headers: {},
+					query: {},
+					status: 200,
+					responseHeaders: {},
+					duration: 10,
+				});
+			}
+
+			const requests = await telescope.getRequests({ limit: 2 });
+			expect(requests).toHaveLength(2);
+		});
+	});
+
+	describe('getStats', () => {
+		it('should return aggregated statistics', async () => {
+			await telescope.recordRequest({
+				method: 'GET',
+				path: '/api/test',
+				url: 'http://localhost/api/test',
+				headers: {},
+				query: {},
+				status: 200,
+				responseHeaders: {},
+				duration: 10,
+			});
+
+			await telescope.info('Test log');
+			await telescope.exception(new Error('Test error'));
+
+			const stats = await telescope.getStats();
+
+			expect(stats.requests).toBe(1);
+			expect(stats.logs).toBe(1);
+			expect(stats.exceptions).toBe(1);
+		});
+	});
+
+	describe('prune', () => {
+		it('should remove old entries', async () => {
+			// Add an old entry directly to storage
+			await storage.saveRequest({
+				id: 'old-req',
+				method: 'GET',
+				path: '/old',
+				url: 'http://localhost/old',
+				headers: {},
+				query: {},
+				status: 200,
+				responseHeaders: {},
+				duration: 10,
+				timestamp: new Date('2020-01-01'),
+			});
+
+			// Add a new entry
+			await telescope.recordRequest({
+				method: 'GET',
+				path: '/new',
+				url: 'http://localhost/new',
+				headers: {},
+				query: {},
+				status: 200,
+				responseHeaders: {},
+				duration: 10,
+			});
+
+			const deleted = await telescope.prune(new Date('2023-01-01'));
+
+			expect(deleted).toBe(1);
+
+			const requests = await telescope.getRequests();
+			expect(requests).toHaveLength(1);
+			expect(requests[0].path).toBe('/new');
+		});
+	});
+
+	describe('auto-prune', () => {
+		it('should configure pruneAfterHours option', () => {
+			const autoPrune = new Telescope({
+				storage,
+				pruneAfterHours: 1,
+			});
+
+			// Verify the telescope was created with pruneAfterHours
+			// The actual pruning is tested via the prune() method
+			expect(autoPrune).toBeDefined();
+
+			autoPrune.destroy();
+		});
+	});
+
+	describe('getRequestId option', () => {
+		it('should use custom getRequestId function when provided', async () => {
+			const customTelescope = new Telescope({
+				storage,
+				getRequestId: () => 'custom-request-id-123',
+			});
+
+			const requestId = await customTelescope.recordRequest({
+				method: 'GET',
+				path: '/api/test',
+				url: 'http://localhost/api/test',
+				headers: {},
+				query: {},
+				status: 200,
+				responseHeaders: {},
+				duration: 10,
+			});
+
+			expect(requestId).toBe('custom-request-id-123');
+
+			const request = await customTelescope.getRequest('custom-request-id-123');
+			expect(request).not.toBeNull();
+			expect(request?.id).toBe('custom-request-id-123');
+
+			customTelescope.destroy();
+		});
+
+		it('should fallback to nanoid when getRequestId returns undefined', async () => {
+			const customTelescope = new Telescope({
+				storage,
+				getRequestId: () => undefined,
+			});
+
+			const requestId = await customTelescope.recordRequest({
+				method: 'GET',
+				path: '/api/test',
+				url: 'http://localhost/api/test',
+				headers: {},
+				query: {},
+				status: 200,
+				responseHeaders: {},
+				duration: 10,
+			});
+
+			// Should fall back to nanoid (21 chars)
+			expect(requestId).toBeDefined();
+			expect(requestId.length).toBe(21);
+			expect(requestId).not.toBe('');
+
+			customTelescope.destroy();
+		});
+
+		it('should work with dynamic request ID getter', async () => {
+			let currentRequestId: string | undefined;
+
+			const customTelescope = new Telescope({
+				storage,
+				getRequestId: () => currentRequestId,
+			});
+
+			// First request - no context
+			currentRequestId = undefined;
+			const id1 = await customTelescope.recordRequest({
+				method: 'GET',
+				path: '/api/test1',
+				url: 'http://localhost/api/test1',
+				headers: {},
+				query: {},
+				status: 200,
+				responseHeaders: {},
+				duration: 10,
+			});
+			expect(id1.length).toBe(21); // nanoid fallback
+
+			// Second request - with context
+			currentRequestId = 'context-id-456';
+			const id2 = await customTelescope.recordRequest({
+				method: 'GET',
+				path: '/api/test2',
+				url: 'http://localhost/api/test2',
+				headers: {},
+				query: {},
+				status: 200,
+				responseHeaders: {},
+				duration: 10,
+			});
+			expect(id2).toBe('context-id-456');
+
+			customTelescope.destroy();
+		});
+	});
+
+	describe('WebSocket clients', () => {
+		it('should manage WebSocket client connections', () => {
+			const mockWs = {
+				send: vi.fn(),
+				readyState: 1, // OPEN
+			} as unknown as WebSocket;
+
+			telescope.addWsClient(mockWs);
+
+			// Broadcast should send to client (including the 'connected' event)
+			const callCount = mockWs.send.mock.calls.length;
+			expect(callCount).toBeGreaterThan(0);
+
+			telescope.removeWsClient(mockWs);
+
+			// After removal, broadcast should not send
+			const newMock = vi.fn();
+			mockWs.send = newMock;
+			telescope.broadcast({
+				type: 'request',
+				payload: {},
+				timestamp: Date.now(),
+			});
+
+			expect(newMock).not.toHaveBeenCalled();
+		});
+
+		it('should broadcast to all connected clients', () => {
+			const ws1 = { send: vi.fn() } as unknown as WebSocket;
+			const ws2 = { send: vi.fn() } as unknown as WebSocket;
+
+			telescope.addWsClient(ws1);
+			telescope.addWsClient(ws2);
+
+			telescope.broadcast({
+				type: 'log',
+				payload: { test: true },
+				timestamp: Date.now(),
+			});
+
+			// Both should receive the broadcast
+			expect(ws1.send).toHaveBeenCalled();
+			expect(ws2.send).toHaveBeenCalled();
+		});
+	});
+});

package/src/__tests__/pino-transport.spec.ts

@@ -0,0 +1,115 @@
+import pino from 'pino';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createPinoTransport } from '../logger/pino';
+import { InMemoryStorage } from '../storage/memory';
+import { Telescope } from '../Telescope';
+
+describe('createPinoTransport', () => {
+	let telescope: Telescope;
+	let storage: InMemoryStorage;
+
+	beforeEach(() => {
+		storage = new InMemoryStorage({ maxEntries: 100 });
+		telescope = new Telescope({ storage, enabled: true });
+	});
+
+	afterEach(() => {
+		telescope.destroy();
+	});
+
+	it('should send logs to telescope when configured like apps/example/src/config/logger.ts', async () => {
+		// This mirrors the exact setup in apps/example/src/config/logger.ts
+		const logger = pino(
+			{
+				level: 'debug',
+				formatters: {
+					bindings() {
+						return { nodeVersion: process.version };
+					},
+					level: (label) => {
+						return { level: label.toUpperCase() };
+					},
+				},
+			},
+			pino.multistream([
+				{ stream: process.stdout },
+				{ stream: createPinoTransport({ telescope }) },
+			]),
+		);
+
+		logger.info('Test log message');
+		logger.info({ userId: '123' }, 'User logged in');
+
+		// Wait for the transport to process and flush
+		await new Promise((resolve) => setTimeout(resolve, 1500));
+
+		const logs = await telescope.getLogs();
+		expect(logs.length).toBeGreaterThanOrEqual(1);
+	});
+
+	it('should NOT have logs before flush interval (default 1000ms)', async () => {
+		const logger = pino(
+			{
+				level: 'debug',
+				formatters: {
+					bindings() {
+						return { nodeVersion: process.version };
+					},
+					level: (label) => {
+						return { level: label.toUpperCase() };
+					},
+				},
+			},
+			pino.multistream([
+				{ stream: process.stdout },
+				{ stream: createPinoTransport({ telescope }) },
+			]),
+		);
+
+		logger.info('Test before flush');
+
+		// Check immediately - should NOT be flushed yet
+		const _logsImmediate = await telescope.getLogs();
+
+		// Check at 500ms - should NOT be flushed yet
+		await new Promise((resolve) => setTimeout(resolve, 500));
+		const _logs500ms = await telescope.getLogs();
+
+		// Check at 1200ms - SHOULD be flushed
+		await new Promise((resolve) => setTimeout(resolve, 700));
+		const logs1200ms = await telescope.getLogs();
+
+		expect(logs1200ms.length).toBeGreaterThanOrEqual(1);
+	});
+
+	it('should verify log content matches what was logged', async () => {
+		const logger = pino(
+			{
+				level: 'debug',
+				formatters: {
+					bindings() {
+						return { nodeVersion: process.version };
+					},
+					level: (label) => {
+						return { level: label.toUpperCase() };
+					},
+				},
+			},
+			pino.multistream([
+				{ stream: process.stdout },
+				{ stream: createPinoTransport({ telescope }) },
+			]),
+		);
+
+		logger.info({ customField: 'test-value' }, 'Specific test message');
+
+		await new Promise((resolve) => setTimeout(resolve, 1500));
+
+		const logs = await telescope.getLogs();
+
+		const matchingLog = logs.find((l) => l.message === 'Specific test message');
+		expect(matchingLog).toBeDefined();
+		expect(matchingLog?.level).toBe('info');
+		expect(matchingLog?.context?.customField).toBe('test-value');
+	});
+});