@geekmidas/telescope 1.1.1 → 10.0.0-alpha.0

package/src/instrumentation/__tests__/core.spec.ts

@@ -1,248 +0,0 @@
-import type { SpanExporter } from '@opentelemetry/sdk-trace-base';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-	createSpanProcessor,
-	flushTelemetry,
-	getRecommendedStrategy,
-	isTelemetryInitialized,
-	NoopSpanProcessor,
-	setGlobalLogProcessor,
-	setGlobalSpanProcessor,
-	shutdownTelemetry,
-	withTelemetryFlush,
-} from '../core';
-
-describe('core telemetry utilities', () => {
-	beforeEach(async () => {
-		// Reset state before each test
-		await shutdownTelemetry();
-	});
-
-	afterEach(async () => {
-		await shutdownTelemetry();
-	});
-
-	describe('createSpanProcessor', () => {
-		const mockExporter: SpanExporter = {
-			export: vi.fn(),
-			shutdown: vi.fn().mockResolvedValue(undefined),
-		};
-
-		it('should create a simple span processor when strategy is simple', () => {
-			const processor = createSpanProcessor(mockExporter, {
-				strategy: 'simple',
-			});
-
-			expect(processor).toBeDefined();
-			expect(processor.forceFlush).toBeDefined();
-		});
-
-		it('should create a batch span processor when strategy is batch', () => {
-			const processor = createSpanProcessor(mockExporter, {
-				strategy: 'batch',
-			});
-
-			expect(processor).toBeDefined();
-			expect(processor.forceFlush).toBeDefined();
-		});
-
-		it('should create batch processor with custom options', () => {
-			const processor = createSpanProcessor(mockExporter, {
-				strategy: 'batch',
-				maxQueueSize: 1024,
-				scheduledDelayMillis: 1000,
-				exportTimeoutMillis: 10000,
-				maxExportBatchSize: 256,
-			});
-
-			expect(processor).toBeDefined();
-		});
-
-		it('should default to batch when strategy is not simple', () => {
-			const processor = createSpanProcessor(mockExporter, {
-				strategy: 'batch',
-			});
-
-			expect(processor).toBeDefined();
-		});
-	});
-
-	describe('getRecommendedStrategy', () => {
-		it('should return simple for lambda environment', () => {
-			expect(getRecommendedStrategy('lambda')).toBe('simple');
-		});
-
-		it('should return simple for edge environment', () => {
-			expect(getRecommendedStrategy('edge')).toBe('simple');
-		});
-
-		it('should return batch for server environment', () => {
-			expect(getRecommendedStrategy('server')).toBe('batch');
-		});
-
-		it('should return batch for custom environment', () => {
-			expect(getRecommendedStrategy('custom')).toBe('batch');
-		});
-	});
-
-	describe('global state management', () => {
-		it('should track initialization state', () => {
-			expect(isTelemetryInitialized()).toBe(false);
-
-			const processor = new NoopSpanProcessor();
-			setGlobalSpanProcessor(processor);
-
-			expect(isTelemetryInitialized()).toBe(true);
-		});
-
-		it('should set and use global log processor', () => {
-			const mockLogProcessor = {
-				forceFlush: vi.fn().mockResolvedValue(undefined),
-				shutdown: vi.fn().mockResolvedValue(undefined),
-			};
-
-			setGlobalLogProcessor(mockLogProcessor);
-			// The log processor is stored internally
-		});
-	});
-
-	describe('flushTelemetry', () => {
-		it('should flush span processor', async () => {
-			const processor = new NoopSpanProcessor();
-			const flushSpy = vi.spyOn(processor, 'forceFlush');
-			setGlobalSpanProcessor(processor);
-
-			await flushTelemetry();
-
-			expect(flushSpy).toHaveBeenCalled();
-		});
-
-		it('should flush log processor if available', async () => {
-			const mockLogProcessor = {
-				forceFlush: vi.fn().mockResolvedValue(undefined),
-			};
-			setGlobalLogProcessor(mockLogProcessor);
-
-			await flushTelemetry();
-
-			expect(mockLogProcessor.forceFlush).toHaveBeenCalled();
-		});
-
-		it('should handle flush timeout gracefully', async () => {
-			const slowProcessor = {
-				forceFlush: vi
-					.fn()
-					.mockImplementation(
-						() => new Promise((resolve) => setTimeout(resolve, 100000)),
-					),
-				onStart: vi.fn(),
-				onEnd: vi.fn(),
-				shutdown: vi.fn().mockResolvedValue(undefined),
-			};
-			setGlobalSpanProcessor(slowProcessor);
-
-			// Should not throw, should timeout gracefully
-			await flushTelemetry(10); // Very short timeout
-		});
-
-		it('should do nothing if not initialized', async () => {
-			// No processor set, should complete without error
-			await flushTelemetry();
-		});
-	});
-
-	describe('shutdownTelemetry', () => {
-		it('should shutdown span processor', async () => {
-			const processor = new NoopSpanProcessor();
-			const shutdownSpy = vi.spyOn(processor, 'shutdown');
-			setGlobalSpanProcessor(processor);
-
-			await shutdownTelemetry();
-
-			expect(shutdownSpy).toHaveBeenCalled();
-			expect(isTelemetryInitialized()).toBe(false);
-		});
-
-		it('should shutdown log processor if available', async () => {
-			const mockLogProcessor = {
-				forceFlush: vi.fn().mockResolvedValue(undefined),
-				shutdown: vi.fn().mockResolvedValue(undefined),
-			};
-			setGlobalLogProcessor(mockLogProcessor);
-
-			await shutdownTelemetry();
-
-			expect(mockLogProcessor.shutdown).toHaveBeenCalled();
-		});
-
-		it('should handle multiple shutdowns gracefully', async () => {
-			const processor = new NoopSpanProcessor();
-			setGlobalSpanProcessor(processor);
-
-			await shutdownTelemetry();
-			await shutdownTelemetry(); // Second call should be safe
-		});
-	});
-
-	describe('withTelemetryFlush', () => {
-		it('should wrap handler and flush after execution', async () => {
-			const processor = new NoopSpanProcessor();
-			const flushSpy = vi.spyOn(processor, 'forceFlush');
-			setGlobalSpanProcessor(processor);
-
-			const mockHandler = vi.fn().mockResolvedValue({ result: 'success' });
-			const wrappedHandler = withTelemetryFlush(mockHandler);
-
-			const result = await wrappedHandler({ event: 'test' }, {});
-
-			expect(result).toEqual({ result: 'success' });
-			expect(mockHandler).toHaveBeenCalledWith({ event: 'test' }, {});
-			expect(flushSpy).toHaveBeenCalled();
-		});
-
-		it('should flush even when handler throws', async () => {
-			const processor = new NoopSpanProcessor();
-			const flushSpy = vi.spyOn(processor, 'forceFlush');
-			setGlobalSpanProcessor(processor);
-
-			const mockHandler = vi.fn().mockRejectedValue(new Error('Handler error'));
-			const wrappedHandler = withTelemetryFlush(mockHandler);
-
-			await expect(wrappedHandler({ event: 'test' }, {})).rejects.toThrow(
-				'Handler error',
-			);
-			expect(flushSpy).toHaveBeenCalled();
-		});
-	});
-
-	describe('NoopSpanProcessor', () => {
-		it('should implement SpanProcessor interface', () => {
-			const processor = new NoopSpanProcessor();
-
-			expect(processor.forceFlush).toBeDefined();
-			expect(processor.onStart).toBeDefined();
-			expect(processor.onEnd).toBeDefined();
-			expect(processor.shutdown).toBeDefined();
-		});
-
-		it('should resolve forceFlush immediately', async () => {
-			const processor = new NoopSpanProcessor();
-			await processor.forceFlush();
-		});
-
-		it('should resolve shutdown immediately', async () => {
-			const processor = new NoopSpanProcessor();
-			await processor.shutdown();
-		});
-
-		it('should do nothing on onStart', () => {
-			const processor = new NoopSpanProcessor();
-			processor.onStart({} as any);
-		});
-
-		it('should do nothing on onEnd', () => {
-			const processor = new NoopSpanProcessor();
-			processor.onEnd({} as any);
-		});
-	});
-});

package/src/instrumentation/__tests__/hono.spec.ts

@@ -1,348 +0,0 @@
-import { trace } from '@opentelemetry/api';
-import {
-	BasicTracerProvider,
-	InMemorySpanExporter,
-	SimpleSpanProcessor,
-} from '@opentelemetry/sdk-trace-base';
-import { Hono } from 'hono';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import {
-	getSpanFromContext,
-	getTraceContextFromHono,
-	honoTelemetryMiddleware,
-	withHonoSpanContext,
-} from '../hono';
-
-describe('honoTelemetryMiddleware', () => {
-	let app: Hono;
-	let exporter: InMemorySpanExporter;
-	let provider: BasicTracerProvider;
-
-	beforeEach(() => {
-		// Set up real OpenTelemetry with in-memory exporter
-		exporter = new InMemorySpanExporter();
-		provider = new BasicTracerProvider();
-		provider.addSpanProcessor(new SimpleSpanProcessor(exporter));
-		provider.register();
-
-		app = new Hono();
-	});
-
-	afterEach(async () => {
-		exporter.reset();
-		await provider.shutdown();
-		trace.disable();
-	});
-
-	describe('span creation', () => {
-		it('should create span for GET requests', async () => {
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users', (c) => {
-				const span = getSpanFromContext(c);
-				expect(span).toBeDefined();
-				return c.json({ users: [] });
-			});
-
-			const response = await app.request('/api/users');
-
-			expect(response.status).toBe(200);
-			const spans = exporter.getFinishedSpans();
-			expect(spans).toHaveLength(1);
-			expect(spans[0].name).toBe('GET /api/users');
-			expect(spans[0].attributes['http.request.method']).toBe('GET');
-		});
-
-		it('should create span for POST requests with attributes', async () => {
-			app.use('*', honoTelemetryMiddleware());
-			app.post('/api/users', (c) => c.json({ id: '123' }, 201));
-
-			const response = await app.request('/api/users', {
-				method: 'POST',
-				headers: {
-					'Content-Type': 'application/json',
-					'User-Agent': 'test-agent',
-				},
-				body: JSON.stringify({ name: 'John' }),
-			});
-
-			expect(response.status).toBe(201);
-			const spans = exporter.getFinishedSpans();
-			expect(spans[0].attributes['http.request.method']).toBe('POST');
-			expect(spans[0].attributes['http.response.status_code']).toBe(201);
-			expect(spans[0].attributes['user_agent.original']).toBe('test-agent');
-		});
-
-		it('should handle errors and record error status', async () => {
-			// Note: Hono catches errors internally before they propagate to middleware,
-			// so we can only detect the 500 status code, not record the actual exception
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/error', () => {
-				throw new Error('Test error');
-			});
-
-			const response = await app.request('/api/error');
-
-			expect(response.status).toBe(500);
-			const spans = exporter.getFinishedSpans();
-			expect(spans).toHaveLength(1);
-			expect(spans[0].attributes['http.response.status_code']).toBe(500);
-			expect(spans[0].status.code).toBe(2); // SpanStatusCode.ERROR
-		});
-
-		it('should record 4xx status codes', async () => {
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users/:id', (c) => c.json({ error: 'Not found' }, 404));
-
-			const response = await app.request('/api/users/999');
-
-			expect(response.status).toBe(404);
-			const spans = exporter.getFinishedSpans();
-			expect(spans[0].attributes['http.response.status_code']).toBe(404);
-			expect(spans[0].status.code).toBe(2); // SpanStatusCode.ERROR
-		});
-	});
-
-	describe('path filtering', () => {
-		it('should skip paths in ignorePaths (exact match)', async () => {
-			app.use(
-				'*',
-				honoTelemetryMiddleware({
-					ignorePaths: ['/health', '/metrics'],
-				}),
-			);
-			app.get('/health', (c) => c.json({ status: 'ok' }));
-
-			await app.request('/health');
-
-			expect(exporter.getFinishedSpans()).toHaveLength(0);
-		});
-
-		it('should skip paths matching wildcard patterns', async () => {
-			app.use(
-				'*',
-				honoTelemetryMiddleware({
-					ignorePaths: ['/__telescope/*'],
-				}),
-			);
-			app.get('/__telescope/requests', (c) => c.json({ requests: [] }));
-
-			await app.request('/__telescope/requests');
-
-			expect(exporter.getFinishedSpans()).toHaveLength(0);
-		});
-
-		it('should trace paths not in ignorePaths', async () => {
-			app.use(
-				'*',
-				honoTelemetryMiddleware({
-					ignorePaths: ['/health'],
-				}),
-			);
-			app.get('/api/users', (c) => c.json({ users: [] }));
-
-			await app.request('/api/users');
-
-			expect(exporter.getFinishedSpans()).toHaveLength(1);
-		});
-	});
-
-	describe('custom shouldSkip', () => {
-		it('should skip requests when shouldSkip returns true', async () => {
-			app.use(
-				'*',
-				honoTelemetryMiddleware({
-					shouldSkip: (c) => c.req.header('x-skip-trace') === 'true',
-				}),
-			);
-			app.get('/api/users', (c) => c.json({ users: [] }));
-
-			await app.request('/api/users', {
-				headers: { 'x-skip-trace': 'true' },
-			});
-
-			expect(exporter.getFinishedSpans()).toHaveLength(0);
-		});
-
-		it('should trace requests when shouldSkip returns false', async () => {
-			app.use(
-				'*',
-				honoTelemetryMiddleware({
-					shouldSkip: (c) => c.req.header('x-skip-trace') === 'true',
-				}),
-			);
-			app.get('/api/users', (c) => c.json({ users: [] }));
-
-			await app.request('/api/users');
-
-			expect(exporter.getFinishedSpans()).toHaveLength(1);
-		});
-	});
-
-	describe('user ID extraction', () => {
-		it('should extract user ID using custom function', async () => {
-			app.use(
-				'*',
-				honoTelemetryMiddleware({
-					getUserId: (c) => c.req.header('x-user-id'),
-				}),
-			);
-			app.get('/api/profile', (c) => c.json({ name: 'John' }));
-
-			await app.request('/api/profile', {
-				headers: { 'x-user-id': 'user-123' },
-			});
-
-			const spans = exporter.getFinishedSpans();
-			expect(spans[0].attributes['enduser.id']).toBe('user-123');
-		});
-
-		it('should not add user attribute when getUserId returns undefined', async () => {
-			app.use(
-				'*',
-				honoTelemetryMiddleware({
-					getUserId: () => undefined,
-				}),
-			);
-			app.get('/api/users', (c) => c.json({ users: [] }));
-
-			await app.request('/api/users');
-
-			const spans = exporter.getFinishedSpans();
-			expect(spans[0].attributes['enduser.id']).toBeUndefined();
-		});
-	});
-
-	describe('client IP extraction', () => {
-		it('should extract IP from x-forwarded-for header', async () => {
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users', (c) => c.json({ users: [] }));
-
-			await app.request('/api/users', {
-				headers: { 'x-forwarded-for': '192.168.1.1, 10.0.0.1' },
-			});
-
-			const spans = exporter.getFinishedSpans();
-			expect(spans[0].attributes['client.address']).toBe('192.168.1.1');
-		});
-
-		it('should extract IP from x-real-ip header', async () => {
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users', (c) => c.json({ users: [] }));
-
-			await app.request('/api/users', {
-				headers: { 'x-real-ip': '10.0.0.5' },
-			});
-
-			const spans = exporter.getFinishedSpans();
-			expect(spans[0].attributes['client.address']).toBe('10.0.0.5');
-		});
-
-		it('should extract IP from cf-connecting-ip header (Cloudflare)', async () => {
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users', (c) => c.json({ users: [] }));
-
-			await app.request('/api/users', {
-				headers: { 'cf-connecting-ip': '203.0.113.195' },
-			});
-
-			const spans = exporter.getFinishedSpans();
-			expect(spans[0].attributes['client.address']).toBe('203.0.113.195');
-		});
-	});
-
-	describe('trace context helpers', () => {
-		it('should provide trace context via getTraceContextFromHono', async () => {
-			let traceContext: any;
-
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users', (c) => {
-				traceContext = getTraceContextFromHono(c);
-				return c.json({ users: [] });
-			});
-
-			await app.request('/api/users');
-
-			expect(traceContext).toBeDefined();
-		});
-
-		it('should run function within span context via withHonoSpanContext', async () => {
-			let result: string | undefined;
-
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users', async (c) => {
-				result = await withHonoSpanContext(c, async () => 'executed');
-				return c.json({ users: [] });
-			});
-
-			await app.request('/api/users');
-
-			expect(result).toBe('executed');
-		});
-	});
-
-	describe('request ID extraction', () => {
-		it('should extract request ID from x-request-id header', async () => {
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users', (c) => c.json({ users: [] }));
-
-			await app.request('/api/users', {
-				headers: { 'x-request-id': 'req-abc123' },
-			});
-
-			const spans = exporter.getFinishedSpans();
-			expect(spans[0].attributes['http.request.id']).toBe('req-abc123');
-		});
-
-		it('should extract request ID from x-amzn-requestid header', async () => {
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users', (c) => c.json({ users: [] }));
-
-			await app.request('/api/users', {
-				headers: { 'x-amzn-requestid': 'amzn-req-456' },
-			});
-
-			const spans = exporter.getFinishedSpans();
-			expect(spans[0].attributes['http.request.id']).toBe('amzn-req-456');
-		});
-	});
-
-	describe('URL attributes', () => {
-		it('should capture full URL and path', async () => {
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users', (c) => c.json({ users: [] }));
-
-			await app.request('http://localhost/api/users?page=1');
-
-			const spans = exporter.getFinishedSpans();
-			expect(spans[0].attributes['url.full']).toContain('/api/users');
-			expect(spans[0].attributes['url.path']).toBe('/api/users');
-			expect(spans[0].attributes['server.address']).toBe('localhost');
-		});
-
-		it('should capture scheme', async () => {
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users', (c) => c.json({ users: [] }));
-
-			await app.request('https://api.example.com/api/users');
-
-			const spans = exporter.getFinishedSpans();
-			expect(spans[0].attributes['url.scheme']).toBe('https');
-		});
-	});
-
-	describe('multiple requests', () => {
-		it('should create separate spans for each request', async () => {
-			app.use('*', honoTelemetryMiddleware());
-			app.get('/api/users', (c) => c.json({ users: [] }));
-			app.post('/api/users', (c) => c.json({ id: '1' }, 201));
-
-			await app.request('/api/users');
-			await app.request('/api/users', { method: 'POST' });
-
-			const spans = exporter.getFinishedSpans();
-			expect(spans).toHaveLength(2);
-			expect(spans[0].attributes['http.request.method']).toBe('GET');
-			expect(spans[1].attributes['http.request.method']).toBe('POST');
-		});
-	});
-});