@geekmidas/telescope 10.0.0-alpha.98 → 10.0.0

package/src/__tests__/redact.spec.ts

@@ -0,0 +1,336 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createRedactor, DEFAULT_REDACT_PATHS } from '../redact';
+import { InMemoryStorage } from '../storage/memory';
+import { Telescope } from '../Telescope';
+
+describe('createRedactor', () => {
+	it('should return undefined when options is undefined', () => {
+		expect(createRedactor(undefined)).toBeUndefined();
+	});
+
+	it('should return undefined when options is false', () => {
+		expect(createRedactor(false)).toBeUndefined();
+	});
+
+	it('should create redactor with default paths when options is true', () => {
+		const redactor = createRedactor(true);
+		expect(redactor).toBeDefined();
+
+		const data = { headers: { authorization: 'Bearer secret' } };
+		const result = redactor?.(data);
+		expect(result.headers.authorization).toBe('[REDACTED]');
+	});
+
+	it('should merge custom paths with defaults when array is provided', () => {
+		const redactor = createRedactor(['custom.secret']);
+		expect(redactor).toBeDefined();
+
+		// Should redact default paths
+		const data1 = { headers: { authorization: 'Bearer token' } };
+		expect(redactor?.(data1).headers.authorization).toBe('[REDACTED]');
+
+		// Should redact custom paths
+		const data2 = { custom: { secret: 'mysecret' } };
+		expect(redactor?.(data2).custom.secret).toBe('[REDACTED]');
+	});
+
+	it('should use custom censor value', () => {
+		const redactor = createRedactor({ paths: [], censor: '***' });
+		expect(redactor).toBeDefined();
+
+		const data = { headers: { authorization: 'Bearer token' } };
+		const result = redactor?.(data);
+		expect(result.headers.authorization).toBe('***');
+	});
+
+	it('should not modify unmatched paths', () => {
+		const redactor = createRedactor(true);
+
+		const data = {
+			headers: { 'content-type': 'application/json' },
+			body: { username: 'john', email: 'john@example.com' },
+		};
+		const result = redactor?.(data);
+
+		expect(result.headers['content-type']).toBe('application/json');
+		expect(result.body.username).toBe('john');
+		expect(result.body.email).toBe('john@example.com');
+	});
+});
+
+describe('DEFAULT_REDACT_PATHS', () => {
+	it('should include common HTTP header paths', () => {
+		expect(DEFAULT_REDACT_PATHS).toContain('headers.authorization');
+		expect(DEFAULT_REDACT_PATHS).toContain('headers.cookie');
+	});
+
+	it('should include body sensitive field paths', () => {
+		expect(DEFAULT_REDACT_PATHS).toContain('body.password');
+		expect(DEFAULT_REDACT_PATHS).toContain('body.token');
+		expect(DEFAULT_REDACT_PATHS).toContain('body.apiKey');
+	});
+
+	it('should include context paths for log redaction', () => {
+		expect(DEFAULT_REDACT_PATHS).toContain('context.password');
+		expect(DEFAULT_REDACT_PATHS).toContain('context.token');
+	});
+});
+
+describe('Telescope with redaction', () => {
+	let telescope: Telescope;
+	let storage: InMemoryStorage;
+
+	beforeEach(() => {
+		storage = new InMemoryStorage();
+	});
+
+	afterEach(() => {
+		telescope?.destroy();
+	});
+
+	describe('recordRequest', () => {
+		it('should redact sensitive headers when redact is enabled', async () => {
+			telescope = new Telescope({ storage, redact: true });
+
+			await telescope.recordRequest({
+				method: 'GET',
+				path: '/api/users',
+				url: 'http://localhost/api/users',
+				headers: {
+					authorization: 'Bearer supersecrettoken',
+					cookie: 'session=abc123',
+					'content-type': 'application/json',
+				},
+				query: {},
+				status: 200,
+				responseHeaders: { 'content-type': 'application/json' },
+				duration: 50,
+			});
+
+			const requests = await telescope.getRequests();
+			expect(requests).toHaveLength(1);
+
+			const req = requests[0];
+			expect(req.headers.authorization).toBe('[REDACTED]');
+			expect(req.headers.cookie).toBe('[REDACTED]');
+			expect(req.headers['content-type']).toBe('application/json');
+		});
+
+		it('should redact sensitive body fields', async () => {
+			telescope = new Telescope({ storage, redact: true });
+
+			await telescope.recordRequest({
+				method: 'POST',
+				path: '/api/login',
+				url: 'http://localhost/api/login',
+				headers: {},
+				query: {},
+				body: {
+					username: 'john',
+					password: 'secret123',
+					token: 'refresh-token-value',
+				},
+				status: 200,
+				responseHeaders: {},
+				responseBody: {
+					accessToken: 'jwt-token',
+					user: { id: '123', name: 'John' },
+				},
+				duration: 100,
+			});
+
+			const requests = await telescope.getRequests();
+			const req = requests[0];
+
+			expect(req.body).toEqual({
+				username: 'john',
+				password: '[REDACTED]',
+				token: '[REDACTED]',
+			});
+
+			expect(req.responseBody).toEqual({
+				accessToken: '[REDACTED]',
+				user: { id: '123', name: 'John' },
+			});
+		});
+
+		it('should redact query parameters', async () => {
+			telescope = new Telescope({ storage, redact: true });
+
+			await telescope.recordRequest({
+				method: 'GET',
+				path: '/api/data',
+				url: 'http://localhost/api/data?token=secret&page=1',
+				headers: {},
+				query: {
+					token: 'secret-token',
+					api_key: 'my-api-key',
+					page: '1',
+				},
+				status: 200,
+				responseHeaders: {},
+				duration: 50,
+			});
+
+			const requests = await telescope.getRequests();
+			const req = requests[0];
+
+			expect(req.query?.token).toBe('[REDACTED]');
+			expect(req.query?.api_key).toBe('[REDACTED]');
+			expect(req.query?.page).toBe('1');
+		});
+
+		it('should not redact when redact option is not set', async () => {
+			telescope = new Telescope({ storage }); // No redact option
+
+			await telescope.recordRequest({
+				method: 'GET',
+				path: '/api/users',
+				url: 'http://localhost/api/users',
+				headers: { authorization: 'Bearer token' },
+				query: {},
+				status: 200,
+				responseHeaders: {},
+				duration: 50,
+			});
+
+			const requests = await telescope.getRequests();
+			expect(requests[0].headers.authorization).toBe('Bearer token');
+		});
+
+		it('should use custom censor value', async () => {
+			telescope = new Telescope({
+				storage,
+				redact: { paths: [], censor: '***HIDDEN***' },
+			});
+
+			await telescope.recordRequest({
+				method: 'GET',
+				path: '/api/users',
+				url: 'http://localhost/api/users',
+				headers: { authorization: 'Bearer token' },
+				query: {},
+				status: 200,
+				responseHeaders: {},
+				duration: 50,
+			});
+
+			const requests = await telescope.getRequests();
+			expect(requests[0].headers.authorization).toBe('***HIDDEN***');
+		});
+	});
+
+	describe('logging', () => {
+		it('should redact sensitive context in info()', async () => {
+			telescope = new Telescope({ storage, redact: true });
+
+			await telescope.info('User authenticated', {
+				userId: '123',
+				password: 'shouldnotshow',
+				token: 'sensitive-token',
+			});
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(1);
+
+			const log = logs[0];
+			expect(log.context?.userId).toBe('123');
+			expect(log.context?.password).toBe('[REDACTED]');
+			expect(log.context?.token).toBe('[REDACTED]');
+		});
+
+		it('should redact context in debug()', async () => {
+			telescope = new Telescope({ storage, redact: true });
+
+			await telescope.debug('Debug info', { secret: 'mysecret' });
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].context?.secret).toBe('[REDACTED]');
+		});
+
+		it('should redact context in warn()', async () => {
+			telescope = new Telescope({ storage, redact: true });
+
+			await telescope.warn('Warning', { apiKey: 'key123' });
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].context?.apiKey).toBe('[REDACTED]');
+		});
+
+		it('should redact context in error()', async () => {
+			telescope = new Telescope({ storage, redact: true });
+
+			await telescope.error('Error occurred', { password: 'pass' });
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].context?.password).toBe('[REDACTED]');
+		});
+
+		it('should redact batch log entries', async () => {
+			telescope = new Telescope({ storage, redact: true });
+
+			await telescope.log([
+				{ level: 'info', message: 'First', context: { token: 'abc' } },
+				{ level: 'debug', message: 'Second', context: { password: 'xyz' } },
+			]);
+
+			const logs = await telescope.getLogs();
+			expect(logs).toHaveLength(2);
+			expect(logs.find((l) => l.message === 'First')?.context?.token).toBe(
+				'[REDACTED]',
+			);
+			expect(logs.find((l) => l.message === 'Second')?.context?.password).toBe(
+				'[REDACTED]',
+			);
+		});
+
+		it('should not redact log message', async () => {
+			telescope = new Telescope({ storage, redact: true });
+
+			await telescope.info('Password changed for user');
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].message).toBe('Password changed for user');
+		});
+	});
+
+	describe('custom paths', () => {
+		it('should redact custom paths merged with defaults', async () => {
+			telescope = new Telescope({
+				storage,
+				redact: ['body.customSecret', 'context.privateData'],
+			});
+
+			await telescope.recordRequest({
+				method: 'POST',
+				path: '/api/data',
+				url: 'http://localhost/api/data',
+				headers: { authorization: 'Bearer token' },
+				query: {},
+				body: {
+					customSecret: 'my-custom-secret',
+					normalField: 'visible',
+				},
+				status: 200,
+				responseHeaders: {},
+				duration: 50,
+			});
+
+			await telescope.info('Log with custom field', {
+				privateData: 'hidden',
+				publicData: 'visible',
+			});
+
+			const requests = await telescope.getRequests();
+			expect(requests[0].headers.authorization).toBe('[REDACTED]');
+			expect(requests[0].body).toEqual({
+				customSecret: '[REDACTED]',
+				normalField: 'visible',
+			});
+
+			const logs = await telescope.getLogs();
+			expect(logs[0].context?.privateData).toBe('[REDACTED]');
+			expect(logs[0].context?.publicData).toBe('visible');
+		});
+	});
+});

package/src/adapters/__tests__/lambda.spec.ts

@@ -0,0 +1,318 @@
+import type { Context as LambdaContext } from 'aws-lambda';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { InMemoryStorage } from '../../storage/memory';
+import { Telescope } from '../../Telescope';
+import {
+	detectLambdaResources,
+	extractLambdaInvocationContext,
+	LambdaAdapter,
+	wrapLambdaHandler,
+} from '../lambda';
+
+describe('Lambda Adapter', () => {
+	let telescope: Telescope;
+	let storage: InMemoryStorage;
+	let mockContext: LambdaContext;
+
+	beforeEach(() => {
+		storage = new InMemoryStorage();
+		telescope = new Telescope({ storage });
+
+		mockContext = {
+			callbackWaitsForEmptyEventLoop: true,
+			functionName: 'test-function',
+			functionVersion: '1',
+			invokedFunctionArn: 'arn:aws:lambda:us-east-1:123456789:function:test',
+			memoryLimitInMB: '256',
+			awsRequestId: 'test-request-id-123',
+			logGroupName: '/aws/lambda/test',
+			logStreamName: '2024/01/01/[$LATEST]abc123',
+			getRemainingTimeInMillis: () => 10000,
+			done: vi.fn(),
+			fail: vi.fn(),
+			succeed: vi.fn(),
+		};
+	});
+
+	describe('detectLambdaResources', () => {
+		it('should detect Lambda environment variables', () => {
+			const originalEnv = { ...process.env };
+
+			process.env.AWS_REGION = 'us-west-2';
+			process.env.AWS_LAMBDA_FUNCTION_NAME = 'my-function';
+			process.env.AWS_LAMBDA_FUNCTION_VERSION = '$LATEST';
+			process.env.AWS_LAMBDA_LOG_STREAM_NAME = 'log-stream-123';
+			process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '512';
+
+			const resources = detectLambdaResources();
+
+			expect(resources['cloud.provider']).toBe('aws');
+			expect(resources['cloud.region']).toBe('us-west-2');
+			expect(resources['faas.name']).toBe('my-function');
+			expect(resources['faas.version']).toBe('$LATEST');
+			expect(resources['faas.instance']).toBe('log-stream-123');
+			expect(resources['faas.max_memory']).toBe(512);
+
+			process.env = originalEnv;
+		});
+
+		it('should return defaults when environment variables are missing', () => {
+			const originalEnv = { ...process.env };
+
+			delete process.env.AWS_REGION;
+			delete process.env.AWS_LAMBDA_FUNCTION_NAME;
+			delete process.env.AWS_LAMBDA_FUNCTION_VERSION;
+			delete process.env.AWS_LAMBDA_LOG_STREAM_NAME;
+			delete process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE;
+
+			const resources = detectLambdaResources();
+
+			expect(resources['cloud.provider']).toBe('aws');
+			expect(resources['cloud.region']).toBe('unknown');
+			expect(resources['faas.name']).toBe('unknown');
+			expect(resources['faas.version']).toBe('unknown');
+			expect(resources['faas.instance']).toBe('unknown');
+			expect(resources['faas.max_memory']).toBe(128); // Default memory
+
+			process.env = originalEnv;
+		});
+	});
+
+	describe('extractLambdaInvocationContext', () => {
+		it('should extract invocation context from Lambda context', () => {
+			const result = extractLambdaInvocationContext({}, mockContext);
+
+			expect(result.requestId).toBe('test-request-id-123');
+			expect(result.remainingTimeMs).toBe(10000);
+			expect(result.memoryLimitMB).toBe(256);
+			expect(result.functionName).toBe('test-function');
+			expect(result.functionVersion).toBe('1');
+		});
+	});
+
+	describe('LambdaAdapter', () => {
+		it('should create adapter with default config', () => {
+			const adapter = new LambdaAdapter(telescope);
+
+			expect(adapter.config.environment).toBe('lambda');
+			expect(adapter.config.autoFlush).toBe(true);
+			expect(adapter.config.detectResource).toBe(true);
+			expect(adapter.config.spanProcessor?.strategy).toBe('simple');
+		});
+
+		it('should merge custom config with defaults', () => {
+			const adapter = new LambdaAdapter(telescope, {
+				autoFlush: false,
+			});
+
+			expect(adapter.config.autoFlush).toBe(false);
+			expect(adapter.config.environment).toBe('lambda'); // Default preserved
+		});
+
+		describe('extractRequestContext', () => {
+			it('should extract context from API Gateway v1 event', () => {
+				const adapter = new LambdaAdapter(telescope);
+				const event = {
+					httpMethod: 'POST',
+					path: '/api/users',
+					headers: { 'Content-Type': 'application/json' },
+					queryStringParameters: { page: '1' },
+					body: JSON.stringify({ name: 'John' }),
+					requestContext: {
+						requestId: 'req-123',
+						identity: { sourceIp: '192.168.1.1' },
+					},
+				};
+
+				const context = adapter.extractRequestContext(event);
+
+				expect(context.method).toBe('POST');
+				expect(context.path).toBe('/api/users');
+				expect(context.query).toEqual({ page: '1' });
+				expect(context.body).toEqual({ name: 'John' });
+				expect(context.ip).toBe('192.168.1.1');
+				expect(context.id).toBe('req-123');
+			});
+
+			it('should extract context from API Gateway v2 event', () => {
+				const adapter = new LambdaAdapter(telescope);
+				const event = {
+					rawPath: '/api/items',
+					headers: { 'content-type': 'application/json' },
+					queryStringParameters: { limit: '10' },
+					body: JSON.stringify({ data: 'test' }),
+					requestContext: {
+						requestId: 'req-456',
+						http: {
+							method: 'GET',
+							sourceIp: '10.0.0.1',
+						},
+					},
+				};
+
+				const context = adapter.extractRequestContext(event);
+
+				expect(context.method).toBe('GET');
+				expect(context.path).toBe('/api/items');
+				expect(context.query).toEqual({ limit: '10' });
+				expect(context.body).toEqual({ data: 'test' });
+				expect(context.ip).toBe('10.0.0.1');
+			});
+
+			it('should extract context from ALB event', () => {
+				const adapter = new LambdaAdapter(telescope);
+				// ALB events don't have requestContext, so the adapter falls back to generic handling
+				const event = {
+					httpMethod: 'DELETE',
+					path: '/api/resource/123',
+					headers: {},
+					queryStringParameters: null,
+					body: null,
+				};
+
+				const context = adapter.extractRequestContext(event);
+
+				expect(context.method).toBe('DELETE');
+				expect(context.path).toBe('/api/resource/123');
+				// ALB without x-forwarded-for will have undefined IP
+				expect(context.ip).toBeUndefined();
+			});
+
+			it('should handle generic Lambda invocation', () => {
+				const adapter = new LambdaAdapter(telescope);
+				const event = { customField: 'value' };
+
+				const context = adapter.extractRequestContext(event);
+
+				expect(context.method).toBe('INVOKE');
+				expect(context.path).toBe('/');
+				expect(context.body).toEqual({ customField: 'value' });
+			});
+
+			it('should handle base64 encoded body', () => {
+				const adapter = new LambdaAdapter(telescope);
+				const bodyContent = { encoded: true };
+				const event = {
+					httpMethod: 'POST',
+					path: '/upload',
+					headers: {},
+					body: Buffer.from(JSON.stringify(bodyContent)).toString('base64'),
+					isBase64Encoded: true,
+				};
+
+				const context = adapter.extractRequestContext(event);
+
+				expect(context.body).toEqual({ encoded: true });
+			});
+		});
+
+		describe('extractResponseContext', () => {
+			it('should extract context from API Gateway response', () => {
+				const adapter = new LambdaAdapter(telescope);
+				const response = {
+					statusCode: 201,
+					headers: { 'x-custom': 'header' },
+					body: JSON.stringify({ created: true }),
+				};
+				const startTime = Date.now() - 100;
+
+				const context = adapter.extractResponseContext(response, startTime);
+
+				expect(context.status).toBe(201);
+				expect(context.headers).toEqual({ 'x-custom': 'header' });
+				expect(context.body).toBe('{"created":true}');
+				expect(context.duration).toBeGreaterThanOrEqual(100);
+			});
+
+			it('should handle generic response', () => {
+				const adapter = new LambdaAdapter(telescope);
+				const response = { data: 'raw' };
+				const startTime = Date.now() - 50;
+
+				const context = adapter.extractResponseContext(response, startTime);
+
+				expect(context.status).toBe(200);
+				expect(context.body).toEqual({ data: 'raw' });
+				// Use 45ms threshold to account for timing variations
+				expect(context.duration).toBeGreaterThanOrEqual(45);
+			});
+		});
+
+		describe('onSetup', () => {
+			it('should detect resources when detectResource is true', async () => {
+				const adapter = new LambdaAdapter(telescope, { detectResource: true });
+
+				await adapter.onSetup();
+
+				expect(adapter.getResourceAttributes()).not.toBeNull();
+			});
+
+			it('should not detect resources when detectResource is false', async () => {
+				const adapter = new LambdaAdapter(telescope, { detectResource: false });
+
+				await adapter.onSetup();
+
+				expect(adapter.getResourceAttributes()).toBeNull();
+			});
+		});
+	});
+
+	describe('wrapLambdaHandler', () => {
+		it('should wrap handler and record successful request', async () => {
+			const baseHandler = async () => ({
+				statusCode: 200,
+				body: JSON.stringify({ ok: true }),
+			});
+
+			const wrappedHandler = wrapLambdaHandler(telescope, baseHandler);
+
+			const event = {
+				httpMethod: 'GET',
+				path: '/health',
+				headers: {},
+				queryStringParameters: null,
+				body: null,
+			};
+
+			const result = await wrappedHandler(event, mockContext);
+
+			expect(result).toEqual({
+				statusCode: 200,
+				body: JSON.stringify({ ok: true }),
+			});
+
+			const requests = await storage.getRequests();
+			expect(requests).toHaveLength(1);
+			expect(requests[0].method).toBe('GET');
+			expect(requests[0].path).toBe('/health');
+			expect(requests[0].status).toBe(200);
+		});
+
+		it('should record exception and rethrow on error', async () => {
+			const error = new Error('Handler error');
+			const baseHandler = async () => {
+				throw error;
+			};
+
+			const wrappedHandler = wrapLambdaHandler(telescope, baseHandler);
+
+			await expect(wrappedHandler({}, mockContext)).rejects.toThrow(
+				'Handler error',
+			);
+
+			const exceptions = await storage.getExceptions();
+			expect(exceptions).toHaveLength(1);
+			expect(exceptions[0].message).toBe('Handler error');
+		});
+
+		it('should pass event and context to handler', async () => {
+			const baseHandler = vi.fn().mockResolvedValue({ statusCode: 200 });
+			const wrappedHandler = wrapLambdaHandler(telescope, baseHandler);
+
+			const event = { test: 'event' };
+			await wrappedHandler(event, mockContext);
+
+			expect(baseHandler).toHaveBeenCalledWith(event, mockContext);
+		});
+	});
+});