@geekmidas/telescope 1.1.1 → 10.0.0-alpha.0

package/src/__tests__/redact.spec.ts

@@ -1,336 +0,0 @@
-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

@@ -1,318 +0,0 @@
-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);
-		});
-	});
-});