@geekmidas/telescope 10.0.0-alpha.99 → 10.0.0

package/src/logger/__tests__/console.spec.ts

@@ -0,0 +1,366 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { InMemoryStorage } from '../../storage/memory';
+import { Telescope } from '../../Telescope';
+import type { Logger } from '../console';
+import { createTelescopeLogger, TelescopeLogger } from '../console';
+
+describe('TelescopeLogger', () => {
+	let telescope: Telescope;
+	let storage: InMemoryStorage;
+
+	beforeEach(() => {
+		storage = new InMemoryStorage();
+		telescope = new Telescope({ storage });
+	});
+
+	afterEach(() => {
+		telescope.destroy();
+	});
+
+	describe('without underlying logger', () => {
+		it('should log to Telescope only', async () => {
+			const logger = new TelescopeLogger({ telescope });
+
+			logger.info({ userId: '123' }, 'User logged in');
+
+			// Wait for async log
+			await new Promise((r) => setTimeout(r, 10));
+
+			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 handle string-only logging', async () => {
+			const logger = new TelescopeLogger({ telescope });
+
+			logger.debug('Simple debug message');
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].message).toBe('Simple debug message');
+			expect(logs[0].level).toBe('debug');
+		});
+	});
+
+	describe('with underlying logger', () => {
+		it('should forward logs to both Telescope and underlying logger', async () => {
+			const mockLogger: Logger = {
+				debug: vi.fn(),
+				info: vi.fn(),
+				warn: vi.fn(),
+				error: vi.fn(),
+				fatal: vi.fn(),
+				trace: vi.fn(),
+				child: vi.fn(() => mockLogger),
+			};
+
+			const logger = new TelescopeLogger({ telescope, logger: mockLogger });
+
+			logger.info({ action: 'test' }, 'Test message');
+
+			expect(mockLogger.info).toHaveBeenCalledWith(
+				{ action: 'test' },
+				'Test message',
+			);
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(1);
+		});
+
+		it('should forward string-only logs to underlying logger', async () => {
+			const mockLogger: Logger = {
+				debug: vi.fn(),
+				info: vi.fn(),
+				warn: vi.fn(),
+				error: vi.fn(),
+				fatal: vi.fn(),
+				trace: vi.fn(),
+				child: vi.fn(() => mockLogger),
+			};
+
+			const logger = new TelescopeLogger({ telescope, logger: mockLogger });
+
+			logger.warn('Warning message');
+
+			expect(mockLogger.warn).toHaveBeenCalledWith('Warning message');
+		});
+	});
+
+	describe('log levels', () => {
+		it('should support all log levels', async () => {
+			const logger = new TelescopeLogger({ telescope });
+
+			logger.debug({}, 'Debug');
+			logger.info({}, 'Info');
+			logger.warn({}, 'Warn');
+			logger.error({}, 'Error');
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			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 map fatal to error level for Telescope', async () => {
+			const logger = new TelescopeLogger({ telescope });
+
+			logger.fatal({}, 'Fatal error');
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].level).toBe('error');
+			expect(logs[0].context).toEqual({ level: 'fatal' });
+		});
+
+		it('should map trace to debug level for Telescope', async () => {
+			const logger = new TelescopeLogger({ telescope });
+
+			logger.trace({}, 'Trace message');
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].level).toBe('debug');
+			expect(logs[0].context).toEqual({ level: 'trace' });
+		});
+
+		it('should handle fatal with string-only and underlying logger', async () => {
+			const mockLogger: Logger = {
+				debug: vi.fn(),
+				info: vi.fn(),
+				warn: vi.fn(),
+				error: vi.fn(),
+				fatal: vi.fn(),
+				trace: vi.fn(),
+				child: vi.fn(() => mockLogger),
+			};
+
+			const logger = new TelescopeLogger({ telescope, logger: mockLogger });
+
+			logger.fatal('Fatal string message');
+
+			expect(mockLogger.fatal).toHaveBeenCalledWith('Fatal string message');
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].level).toBe('error');
+			expect(logs[0].message).toBe('Fatal string message');
+		});
+
+		it('should handle trace with string-only and underlying logger', async () => {
+			const mockLogger: Logger = {
+				debug: vi.fn(),
+				info: vi.fn(),
+				warn: vi.fn(),
+				error: vi.fn(),
+				fatal: vi.fn(),
+				trace: vi.fn(),
+				child: vi.fn(() => mockLogger),
+			};
+
+			const logger = new TelescopeLogger({ telescope, logger: mockLogger });
+
+			logger.trace('Trace string message');
+
+			expect(mockLogger.trace).toHaveBeenCalledWith('Trace string message');
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].level).toBe('debug');
+			expect(logs[0].message).toBe('Trace string message');
+		});
+
+		it('should handle fatal with object and underlying logger', async () => {
+			const mockLogger: Logger = {
+				debug: vi.fn(),
+				info: vi.fn(),
+				warn: vi.fn(),
+				error: vi.fn(),
+				fatal: vi.fn(),
+				trace: vi.fn(),
+				child: vi.fn(() => mockLogger),
+			};
+
+			const logger = new TelescopeLogger({ telescope, logger: mockLogger });
+
+			logger.fatal({ errorCode: 500 }, 'Fatal error message');
+
+			expect(mockLogger.fatal).toHaveBeenCalledWith(
+				{ errorCode: 500 },
+				'Fatal error message',
+			);
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].context).toEqual({ errorCode: 500, level: 'fatal' });
+		});
+
+		it('should handle trace with object and underlying logger', async () => {
+			const mockLogger: Logger = {
+				debug: vi.fn(),
+				info: vi.fn(),
+				warn: vi.fn(),
+				error: vi.fn(),
+				fatal: vi.fn(),
+				trace: vi.fn(),
+				child: vi.fn(() => mockLogger),
+			};
+
+			const logger = new TelescopeLogger({ telescope, logger: mockLogger });
+
+			logger.trace({ traceId: 'abc123' }, 'Trace event');
+
+			expect(mockLogger.trace).toHaveBeenCalledWith(
+				{ traceId: 'abc123' },
+				'Trace event',
+			);
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].context).toEqual({ traceId: 'abc123', level: 'trace' });
+		});
+	});
+
+	describe('child loggers', () => {
+		it('should create child logger with inherited context', async () => {
+			const logger = new TelescopeLogger({
+				telescope,
+				context: { app: 'myApp' },
+			});
+
+			const childLogger = logger.child({ module: 'auth' });
+			childLogger.info({}, 'Child log');
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].context).toEqual({ app: 'myApp', module: 'auth' });
+		});
+
+		it('should create child of underlying logger too', async () => {
+			const childMock: Logger = {
+				debug: vi.fn(),
+				info: vi.fn(),
+				warn: vi.fn(),
+				error: vi.fn(),
+				fatal: vi.fn(),
+				trace: vi.fn(),
+				child: vi.fn(() => childMock),
+			};
+
+			const mockLogger: Logger = {
+				debug: vi.fn(),
+				info: vi.fn(),
+				warn: vi.fn(),
+				error: vi.fn(),
+				fatal: vi.fn(),
+				trace: vi.fn(),
+				child: vi.fn(() => childMock),
+			};
+
+			const logger = new TelescopeLogger({ telescope, logger: mockLogger });
+			const child = logger.child({ module: 'test' });
+
+			expect(mockLogger.child).toHaveBeenCalledWith({ module: 'test' });
+
+			child.info({}, 'Test');
+			expect(childMock.info).toHaveBeenCalled();
+		});
+	});
+
+	describe('withRequestId', () => {
+		it('should bind logs to a request ID', async () => {
+			const logger = new TelescopeLogger({ telescope });
+			const requestLogger = logger.withRequestId('req-123');
+
+			requestLogger.info({}, 'Request log');
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].requestId).toBe('req-123');
+		});
+
+		it('should preserve context when binding request ID', async () => {
+			const logger = new TelescopeLogger({
+				telescope,
+				context: { app: 'test' },
+			});
+			const requestLogger = logger.withRequestId('req-456');
+
+			requestLogger.info({ action: 'test' }, 'Log');
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].context).toEqual({ app: 'test', action: 'test' });
+			expect(logs[0].requestId).toBe('req-456');
+		});
+	});
+
+	describe('createTelescopeLogger factory', () => {
+		it('should create logger without underlying logger', async () => {
+			const logger = createTelescopeLogger(telescope);
+
+			logger.info({}, 'Factory test');
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(1);
+		});
+
+		it('should create logger with underlying logger', async () => {
+			const mockLogger: Logger = {
+				debug: vi.fn(),
+				info: vi.fn(),
+				warn: vi.fn(),
+				error: vi.fn(),
+				fatal: vi.fn(),
+				trace: vi.fn(),
+				child: vi.fn(() => mockLogger),
+			};
+
+			const logger = createTelescopeLogger(telescope, mockLogger);
+
+			logger.error({ err: 'test' }, 'Error message');
+
+			expect(mockLogger.error).toHaveBeenCalled();
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(1);
+		});
+
+		it('should create logger with initial context', async () => {
+			const logger = createTelescopeLogger(telescope, undefined, {
+				service: 'api',
+			});
+
+			logger.info({}, 'With context');
+
+			await new Promise((r) => setTimeout(r, 10));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].context).toEqual({ service: 'api' });
+		});
+	});
+});

package/src/logger/__tests__/pino.spec.ts

@@ -0,0 +1,217 @@
+import pino from 'pino';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { InMemoryStorage } from '../../storage/memory';
+import { Telescope } from '../../Telescope';
+import { createPinoDestination, createPinoTransport } from '../pino';
+
+describe('Pino Transport', () => {
+	let telescope: Telescope;
+	let storage: InMemoryStorage;
+
+	beforeEach(() => {
+		storage = new InMemoryStorage();
+		telescope = new Telescope({ storage });
+	});
+
+	afterEach(() => {
+		telescope.destroy();
+	});
+
+	// Helper to create transport with fast flush for tests
+	const createTestTransport = (
+		opts: Parameters<typeof createPinoTransport>[0],
+	) => createPinoTransport({ flushIntervalMs: 50, ...opts });
+
+	describe('createPinoTransport', () => {
+		it('should parse and forward JSON log lines', async () => {
+			const transport = createTestTransport({ telescope });
+			const logger = pino({ level: 'debug' }, transport);
+
+			logger.info({ userId: '123' }, 'Test message');
+
+			// Wait for flush interval
+			await new Promise((r) => setTimeout(r, 100));
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(1);
+			expect(logs[0].level).toBe('info');
+			expect(logs[0].message).toBe('Test message');
+			expect(logs[0].context).toMatchObject({ userId: '123' });
+		});
+
+		it('should map Pino log levels correctly', async () => {
+			const transport = createTestTransport({ telescope });
+			const logger = pino({ level: 'trace' }, transport);
+
+			logger.trace('Trace message');
+			logger.debug('Debug message');
+			logger.info('Info message');
+			logger.warn('Warn message');
+			logger.error('Error message');
+			logger.fatal('Fatal message');
+
+			await new Promise((r) => setTimeout(r, 150));
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(6);
+
+			const logLevels = logs.map((l) => l.level);
+			expect(logLevels.filter((l) => l === 'debug')).toHaveLength(2); // trace + debug
+			expect(logLevels).toContain('info');
+			expect(logLevels).toContain('warn');
+			expect(logLevels.filter((l) => l === 'error')).toHaveLength(2); // error + fatal
+		});
+
+		it('should extract requestId from log data', async () => {
+			const transport = createTestTransport({ telescope });
+			const logger = pino({ level: 'debug' }, transport);
+
+			logger.info({ requestId: 'req-abc123' }, 'Request log');
+
+			await new Promise((r) => setTimeout(r, 100));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].requestId).toBe('req-abc123');
+			// requestId should not be in context
+			expect(logs[0].context).not.toHaveProperty('requestId');
+		});
+
+		it('should use static requestId option', async () => {
+			const transport = createTestTransport({
+				telescope,
+				requestId: 'static-req-id',
+			});
+			const logger = pino({ level: 'debug' }, transport);
+
+			logger.info('Log with static ID');
+
+			await new Promise((r) => setTimeout(r, 100));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].requestId).toBe('static-req-id');
+		});
+
+		it('should use requestId function option', async () => {
+			const transport = createTestTransport({
+				telescope,
+				requestId: (data) => data.traceId as string | undefined,
+			});
+			const logger = pino({ level: 'debug' }, transport);
+
+			logger.info({ traceId: 'trace-xyz' }, 'Log with extracted ID');
+
+			await new Promise((r) => setTimeout(r, 100));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].requestId).toBe('trace-xyz');
+		});
+
+		it('should handle empty message', async () => {
+			const transport = createTestTransport({ telescope });
+			const logger = pino({ level: 'debug' }, transport);
+
+			logger.info({ data: 'some data' });
+
+			await new Promise((r) => setTimeout(r, 100));
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].message).toBe('');
+		});
+
+		it('should strip Pino metadata from context', async () => {
+			const transport = createTestTransport({ telescope });
+			const logger = pino({ level: 'debug' }, transport);
+
+			logger.info({ customField: 'value' }, 'Test');
+
+			await new Promise((r) => setTimeout(r, 100));
+
+			const logs = await telescope.getLogs();
+			const context = logs[0].context;
+
+			expect(context).not.toHaveProperty('level');
+			expect(context).not.toHaveProperty('msg');
+			expect(context).not.toHaveProperty('time');
+			expect(context).not.toHaveProperty('pid');
+			expect(context).not.toHaveProperty('hostname');
+			expect(context).toMatchObject({ customField: 'value' });
+		});
+
+		it('should return a writable stream', () => {
+			const transport = createPinoTransport({ telescope });
+
+			expect(typeof transport.write).toBe('function');
+			expect(typeof transport.end).toBe('function');
+		});
+
+		it('should batch logs and flush at batchSize', async () => {
+			const transport = createPinoTransport({
+				telescope,
+				batchSize: 3,
+				flushIntervalMs: 5000, // Long interval to test batch size trigger
+			});
+			const logger = pino({ level: 'debug' }, transport);
+
+			// Write 2 logs - should not flush yet
+			logger.info('Log 1');
+			logger.info('Log 2');
+
+			await new Promise((r) => setTimeout(r, 50));
+			let logs = await telescope.getLogs();
+			expect(logs).toHaveLength(0); // Not flushed yet
+
+			// Write 3rd log - should trigger flush
+			logger.info('Log 3');
+
+			await new Promise((r) => setTimeout(r, 100));
+			logs = await telescope.getLogs();
+			expect(logs).toHaveLength(3);
+		});
+
+		it('should flush on close', async () => {
+			const transport = createPinoTransport({
+				telescope,
+				batchSize: 100,
+				flushIntervalMs: 10000, // Long interval
+			});
+			const logger = pino({ level: 'debug' }, transport);
+
+			logger.info('Will be flushed on close');
+
+			// End the stream to trigger close
+			transport.end();
+
+			await new Promise((r) => setTimeout(r, 100));
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(1);
+			expect(logs[0].message).toBe('Will be flushed on close');
+		});
+	});
+
+	describe('createPinoDestination', () => {
+		it('should be an alias for createPinoTransport', () => {
+			const transport = createPinoTransport({ telescope });
+			const destination = createPinoDestination({ telescope });
+
+			expect(typeof transport.write).toBe('function');
+			expect(typeof destination.write).toBe('function');
+		});
+
+		it('should work the same as createPinoTransport', async () => {
+			const destination = createPinoDestination({
+				telescope,
+				flushIntervalMs: 50,
+			});
+			const logger = pino({ level: 'debug' }, destination);
+
+			logger.info('Destination test');
+
+			await new Promise((r) => setTimeout(r, 100));
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(1);
+			expect(logs[0].message).toBe('Destination test');
+		});
+	});
+});