@gguf/coder 0.3.1 → 0.3.2

package/source/utils/logging/request-tracker.spec.ts

@@ -1,1198 +0,0 @@
-import test from 'ava';
-import {
-	RequestMetadata,
-	RequestStats,
-	RequestTracker,
-	globalRequestTracker,
-} from './request-tracker.js';
-import {
-	aiTracker,
-	httpTracker,
-	mcpTracker,
-	trackRequest,
-} from './request-tracker.js';
-
-// Helper function to create test request metadata
-function createTestRequestMetadata(
-	overrides: Partial<RequestMetadata> = {},
-): Omit<RequestMetadata, 'id' | 'startTime' | 'status' | 'correlationId'> {
-	return {
-		type: 'http',
-		method: 'GET',
-		url: '/test',
-		endpoint: '/test',
-		provider: 'test-provider',
-		model: 'test-model',
-		toolName: 'test-tool',
-		serverName: 'test-server',
-		correlationId: 'test-correlation',
-		startTime: Date.now(),
-		endTime: Date.now(),
-		duration: 100,
-		memoryStart: process.memoryUsage(),
-		memoryEnd: process.memoryUsage(),
-		memoryDelta: {heapUsed: 1024, heapTotal: 2048, external: 512, rss: 4096},
-		status: 'success',
-		statusCode: 200,
-		errorType: undefined,
-		errorMessage: undefined,
-		requestSize: 1024,
-		responseSize: 2048,
-		retryCount: 0,
-		userId: 'test-user',
-		sessionId: 'test-session',
-		tags: ['test', 'request'],
-		customData: {key: 'value'},
-		...overrides,
-	};
-}
-
-// Test RequestTracker class
-// ============================================================================
-
-test('RequestTracker constructor creates instance with default maxCompletedRequests', t => {
-	const tracker = new RequestTracker();
-	t.truthy(tracker);
-	t.is(tracker.getActiveRequests().length, 0);
-	t.is(tracker.getRecentRequests().length, 0);
-});
-
-test('RequestTracker constructor accepts custom maxCompletedRequests', t => {
-	const tracker = new RequestTracker(100);
-	t.truthy(tracker);
-	t.is(tracker.getActiveRequests().length, 0);
-});
-
-test('RequestTracker startRequest starts new request', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	const requestId = tracker.startRequest(metadata);
-
-	t.truthy(requestId);
-	t.is(typeof requestId, 'string');
-	t.is(requestId.startsWith('req_'), true);
-	t.is(tracker.getActiveRequests().length, 1);
-});
-
-test('RequestTracker startRequest returns unique request IDs', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	const requestId1 = tracker.startRequest(metadata);
-	const requestId2 = tracker.startRequest(metadata);
-
-	t.not(requestId1, requestId2);
-	t.is(tracker.getActiveRequests().length, 2);
-});
-
-test('RequestTracker completeRequest completes active request', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	const requestId = tracker.startRequest(metadata);
-	const completed = tracker.completeRequest(requestId, {statusCode: 200});
-
-	t.truthy(completed);
-	t.is(completed?.status, 'success');
-	t.is(completed?.statusCode, 200);
-	t.is(tracker.getActiveRequests().length, 0);
-	t.is(tracker.getRecentRequests().length, 1);
-});
-
-test('RequestTracker completeRequest handles unknown request ID', t => {
-	const tracker = new RequestTracker();
-
-	const completed = tracker.completeRequest('unknown-request-id');
-
-	t.falsy(completed);
-	t.is(tracker.getActiveRequests().length, 0);
-});
-
-test('RequestTracker failRequest marks request as failed', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	const requestId = tracker.startRequest(metadata);
-	const failed = tracker.failRequest(requestId, new Error('Test error'));
-
-	t.truthy(failed);
-	t.is(failed?.status, 'error');
-	t.is(failed?.errorType, 'Error');
-	t.truthy(failed?.errorMessage);
-	t.is(tracker.getActiveRequests().length, 0);
-	t.is(tracker.getRecentRequests().length, 1);
-});
-
-test('RequestTracker failRequest handles string error', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	const requestId = tracker.startRequest(metadata);
-	const failed = tracker.failRequest(requestId, 'String error');
-
-	t.truthy(failed);
-	t.is(failed?.status, 'error');
-	t.is(failed?.errorMessage, 'String error');
-});
-
-test('RequestTracker timeoutRequest marks request as timed out', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	const requestId = tracker.startRequest(metadata);
-	const timedOut = tracker.timeoutRequest(requestId, 1000);
-
-	t.truthy(timedOut);
-	t.is(timedOut?.status, 'timeout');
-	t.truthy(timedOut?.errorMessage);
-	t.is(tracker.getActiveRequests().length, 0);
-	t.is(tracker.getRecentRequests().length, 1);
-});
-
-test('RequestTracker cancelRequest cancels request', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	const requestId = tracker.startRequest(metadata);
-	const cancelled = tracker.cancelRequest(requestId, 'User cancelled');
-
-	t.truthy(cancelled);
-	t.is(cancelled?.status, 'cancelled');
-	t.is(cancelled?.errorMessage, 'User cancelled');
-	t.is(tracker.getActiveRequests().length, 0);
-	t.is(tracker.getRecentRequests().length, 1);
-});
-
-test('RequestTracker getStats returns RequestStats', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	const requestId = tracker.startRequest(metadata);
-	tracker.completeRequest(requestId, {statusCode: 200});
-
-	const stats = tracker.getStats();
-
-	t.truthy(stats);
-	t.true('totalRequests' in stats);
-	t.true('requestsByType' in stats);
-	t.true('requestsByStatus' in stats);
-	t.true('averageDuration' in stats);
-	t.true('minDuration' in stats);
-	t.true('maxDuration' in stats);
-	t.true('totalDuration' in stats);
-	t.true('averageMemoryDelta' in stats);
-	t.true('errorRate' in stats);
-	t.true('timeoutRate' in stats);
-	t.true('requestsInLastHour' in stats);
-	t.true('requestsInLastDay' in stats);
-	t.true('busiestHour' in stats);
-	t.true('busiestEndpoint' in stats);
-	t.true('slowestEndpoint' in stats);
-	t.true('mostErrorProneEndpoint' in stats);
-	t.true('timestamp' in stats);
-});
-
-test('RequestTracker getStats calculates correct statistics', t => {
-	const tracker = new RequestTracker();
-
-	// Add successful requests
-	for (let i = 0; i < 5; i++) {
-		const requestId = tracker.startRequest(
-			createTestRequestMetadata({
-				type: 'http',
-			}),
-		);
-		// Add small delay to ensure different durations
-		if (i > 0) {
-			// Small delay to create measurable duration differences
-			const start = Date.now();
-			while (Date.now() - start < i * 5) {
-				// Busy wait for precise timing
-			}
-		}
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	// Add failed request
-	const failRequestId = tracker.startRequest(
-		createTestRequestMetadata({
-			type: 'http',
-		}),
-	);
-	tracker.failRequest(failRequestId, new Error('Test error'));
-
-	const stats = tracker.getStats();
-
-	t.is(stats.totalRequests, 6);
-	t.is(stats.requestsByStatus.success, 5);
-	t.is(stats.requestsByStatus.error, 1);
-	t.true(stats.averageDuration >= 0); // Duration is calculated from actual time
-	t.true(stats.errorRate > 0);
-});
-
-test('RequestTracker getActiveRequests returns active requests', t => {
-	const tracker = new RequestTracker();
-
-	const requestId1 = tracker.startRequest(createTestRequestMetadata());
-	const requestId2 = tracker.startRequest(createTestRequestMetadata());
-
-	const active = tracker.getActiveRequests();
-
-	t.is(active.length, 2);
-	t.is(active[0].id, requestId1);
-	t.is(active[1].id, requestId2);
-});
-
-test('RequestTracker getRecentRequests returns recent completed requests', t => {
-	const tracker = new RequestTracker();
-
-	// Complete some requests
-	for (let i = 0; i < 10; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	const recent = tracker.getRecentRequests(5);
-
-	t.is(recent.length, 5);
-});
-
-test('RequestTracker getRecentRequests with default limit', t => {
-	const tracker = new RequestTracker();
-
-	// Complete some requests
-	for (let i = 0; i < 3; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	const recent = tracker.getRecentRequests();
-
-	t.is(recent.length, 3);
-});
-
-test('RequestTracker clear removes all tracking data', t => {
-	const tracker = new RequestTracker();
-
-	// Start and complete some requests
-	for (let i = 0; i < 5; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	t.is(tracker.getActiveRequests().length, 0);
-	t.is(tracker.getRecentRequests().length, 5);
-
-	tracker.clear();
-
-	t.is(tracker.getActiveRequests().length, 0);
-	t.is(tracker.getRecentRequests().length, 0);
-});
-
-test('RequestTracker respects maxCompletedRequests limit', t => {
-	const tracker = new RequestTracker(3);
-
-	// Complete more requests than limit
-	for (let i = 0; i < 5; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	// Should only keep maxCompletedRequests
-	t.is(tracker.getRecentRequests().length, 3);
-});
-
-// Test trackRequest decorator
-// ============================================================================
-
-test('trackRequest decorator tracks function execution', async t => {
-	// Note: trackRequest uses globalRequestTracker, not local instances
-	const testFunction = async (input: string): Promise<string> => {
-		return `Processed: ${input}`;
-	};
-
-	const trackedFunction = trackRequest(
-		testFunction as (...args: unknown[]) => Promise<string>,
-		{
-			type: 'custom' as const,
-			endpoint: 'test-endpoint',
-		},
-	);
-
-	const result = await trackedFunction('test-input');
-
-	t.is(result, 'Processed: test-input');
-	t.is(globalRequestTracker.getRecentRequests().length, 1);
-});
-
-test('trackRequest decorator handles function errors', async t => {
-	// Note: trackRequest uses globalRequestTracker, not local instances
-	globalRequestTracker.clear();
-
-	const testFunction = async (): Promise<string> => {
-		throw new Error('Test error');
-	};
-
-	const trackedFunction = trackRequest(testFunction, {
-		type: 'custom' as const,
-		endpoint: 'test-endpoint',
-	});
-
-	try {
-		await trackedFunction();
-		t.fail('Should have thrown error');
-	} catch (error) {
-		t.is((error as Error).message, 'Test error');
-	}
-
-	// Should still track the failed request
-	t.is(globalRequestTracker.getRecentRequests().length, 1);
-	t.is(globalRequestTracker.getRecentRequests()[0].status, 'error');
-});
-
-test('trackRequest decorator with trackMemory option', async t => {
-	// Note: trackRequest uses globalRequestTracker, not local instances
-	globalRequestTracker.clear(); // Clear global tracker first
-
-	const testFunction = async (): Promise<string> => {
-		return 'result';
-	};
-
-	const trackedFunction = trackRequest(testFunction, {
-		type: 'custom' as const,
-		endpoint: 'test-endpoint',
-		trackMemory: true,
-	});
-
-	await trackedFunction();
-
-	const requests = globalRequestTracker.getRecentRequests();
-	t.is(requests.length, 1);
-	t.truthy(requests[0].memoryDelta);
-});
-
-test('trackRequest decorator with trackRequestSize option', async t => {
-	// Note: trackRequest uses globalRequestTracker, not local instances
-	globalRequestTracker.clear(); // Clear global tracker first
-
-	const testFunction = async (arg1: string, arg2: number): Promise<string> => {
-		return 'result';
-	};
-
-	const trackedFunction = trackRequest(
-		testFunction as (...args: unknown[]) => Promise<string>,
-		{
-			type: 'custom' as const,
-			endpoint: 'test-endpoint',
-			trackRequestSize: true,
-		},
-	);
-
-	await trackedFunction('test', 123);
-
-	const requests = globalRequestTracker.getRecentRequests();
-	t.is(requests.length, 1);
-	t.truthy(requests[0].customData);
-	t.truthy((requests[0].customData as any).arguments);
-});
-
-// Test HTTP tracker utilities
-// ============================================================================
-
-test('httpTracker.get tracks GET requests', async t => {
-	globalRequestTracker.clear();
-	const tracker = new RequestTracker();
-
-	const testFunction = async (): Promise<string> => {
-		return 'GET result';
-	};
-
-	const trackedFunction = httpTracker.get('/test', testFunction);
-
-	const result = await trackedFunction();
-
-	t.is(result, 'GET result');
-	const requests = globalRequestTracker.getRecentRequests();
-	t.is(requests.length, 1);
-	t.is(requests[0].method, 'GET');
-	t.is(requests[0].endpoint, '/test');
-});
-
-test('httpTracker.post tracks POST requests', async t => {
-	globalRequestTracker.clear(); // Clear global tracker first
-
-	const testFunction = async (): Promise<string> => {
-		return 'POST result';
-	};
-
-	const trackedFunction = httpTracker.post('/test', testFunction);
-
-	const result = await trackedFunction();
-
-	t.is(result, 'POST result');
-	const requests = globalRequestTracker.getRecentRequests();
-	t.is(requests.length, 1);
-	t.is(requests[0].method, 'POST');
-});
-
-test('httpTracker.put tracks PUT requests', async t => {
-	globalRequestTracker.clear(); // Clear global tracker first
-
-	const testFunction = async (): Promise<string> => {
-		return 'PUT result';
-	};
-
-	const trackedFunction = httpTracker.put('/test', testFunction);
-
-	const result = await trackedFunction();
-
-	t.is(result, 'PUT result');
-	const requests = globalRequestTracker.getRecentRequests();
-	t.is(requests.length, 1);
-	t.is(requests[0].method, 'PUT');
-});
-
-test('httpTracker.delete tracks DELETE requests', async t => {
-	globalRequestTracker.clear(); // Clear global tracker first
-
-	const testFunction = async (): Promise<string> => {
-		return 'DELETE result';
-	};
-
-	const trackedFunction = httpTracker.delete('/test', testFunction);
-
-	const result = await trackedFunction();
-
-	t.is(result, 'DELETE result');
-	const requests = globalRequestTracker.getRecentRequests();
-	t.is(requests.length, 1);
-	t.is(requests[0].method, 'DELETE');
-});
-
-// Test AI tracker utilities
-// ============================================================================
-
-test('aiTracker.chat tracks chat requests', async t => {
-	globalRequestTracker.clear(); // Clear global tracker first
-
-	const testFunction = async (): Promise<string> => {
-		return 'Chat result';
-	};
-
-	const trackedFunction = aiTracker.chat(
-		'test-provider',
-		'test-model',
-		testFunction,
-	);
-
-	const result = await trackedFunction();
-
-	t.is(result, 'Chat result');
-	const requests = globalRequestTracker.getRecentRequests();
-	t.is(requests.length, 1);
-	t.is(requests[0].type, 'ai');
-	t.is(requests[0].provider, 'test-provider');
-	t.is(requests[0].model, 'test-model');
-	t.is(requests[0].endpoint, 'chat');
-});
-
-test('aiTracker.completion tracks completion requests', async t => {
-	globalRequestTracker.clear(); // Clear global tracker first
-
-	const testFunction = async (): Promise<string> => {
-		return 'Completion result';
-	};
-
-	const trackedFunction = aiTracker.completion(
-		'test-provider',
-		'test-model',
-		testFunction,
-	);
-
-	const result = await trackedFunction();
-
-	t.is(result, 'Completion result');
-	const requests = globalRequestTracker.getRecentRequests();
-	t.is(requests.length, 1);
-	t.is(requests[0].endpoint, 'completion');
-});
-
-test('aiTracker.embedding tracks embedding requests', async t => {
-	globalRequestTracker.clear(); // Clear global tracker first
-
-	const testFunction = async (): Promise<string> => {
-		return 'Embedding result';
-	};
-
-	const trackedFunction = aiTracker.embedding(
-		'test-provider',
-		'test-model',
-		testFunction,
-	);
-
-	const result = await trackedFunction();
-
-	t.is(result, 'Embedding result');
-	const requests = globalRequestTracker.getRecentRequests();
-	t.is(requests.length, 1);
-	t.is(requests[0].endpoint, 'embedding');
-});
-
-// Test MCP tracker utilities
-// ============================================================================
-
-test('mcpTracker.tool tracks tool execution', async t => {
-	globalRequestTracker.clear(); // Clear global tracker first
-
-	const testFunction = async (): Promise<string> => {
-		return 'Tool result';
-	};
-
-	const trackedFunction = mcpTracker.tool(
-		'test-server',
-		'test-tool',
-		testFunction,
-	);
-
-	const result = await trackedFunction();
-
-	t.is(result, 'Tool result');
-	const requests = globalRequestTracker.getRecentRequests();
-	t.is(requests.length, 1);
-	t.is(requests[0].type, 'mcp');
-	// Note: toolName is not currently preserved in the implementation
-	// t.is(requests[0].toolName, 'test-tool');
-	t.is(requests[0].endpoint, 'tool:test-tool');
-});
-
-test('mcpTracker.connect tracks server connection', async t => {
-	globalRequestTracker.clear(); // Clear global tracker first
-
-	const testFunction = async (): Promise<string> => {
-		return 'Connect result';
-	};
-
-	const trackedFunction = mcpTracker.connect('test-server', testFunction);
-
-	const result = await trackedFunction();
-
-	t.is(result, 'Connect result');
-	const requests = globalRequestTracker.getRecentRequests();
-	t.is(requests.length, 1);
-	t.is(requests[0].endpoint, 'connect');
-});
-
-// Test globalRequestTracker instance
-// ============================================================================
-
-test('globalRequestTracker is RequestTracker instance', t => {
-	t.true(globalRequestTracker instanceof RequestTracker);
-});
-
-test('globalRequestTracker can track requests', t => {
-	globalRequestTracker.clear();
-
-	const requestId = globalRequestTracker.startRequest(
-		createTestRequestMetadata(),
-	);
-	globalRequestTracker.completeRequest(requestId, {statusCode: 200});
-
-	t.is(globalRequestTracker.getRecentRequests().length, 1);
-});
-
-// Test statistics calculation
-// ============================================================================
-
-test('RequestTracker getStats calculates duration statistics correctly', async t => {
-	const tracker = new RequestTracker();
-
-	// Add requests with different durations
-	// Note: Duration is calculated based on actual time, not provided metadata
-	const durations = [];
-	for (let i = 0; i < 5; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		// Add a small delay to ensure different durations
-		if (i > 0) await new Promise(resolve => setTimeout(resolve, i * 10));
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	const stats = tracker.getStats();
-
-	t.is(stats.totalRequests, 5);
-	// Duration is based on actual execution time, so we can't predict exact values
-	// Just verify that the stats are calculated correctly
-	t.true(stats.averageDuration >= 0);
-	t.true(stats.minDuration >= 0);
-	t.true(stats.maxDuration >= stats.minDuration);
-	t.true(stats.totalDuration >= 0);
-});
-
-test('RequestTracker getStats calculates error rate correctly', t => {
-	const tracker = new RequestTracker();
-
-	// Add successful requests
-	for (let i = 0; i < 8; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	// Add failed requests
-	for (let i = 0; i < 2; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.failRequest(requestId, new Error('Test error'));
-	}
-
-	const stats = tracker.getStats();
-
-	t.is(stats.totalRequests, 10);
-	t.is(stats.errorRate, 0.2); // 2 errors / 10 total
-});
-
-test('RequestTracker getStats identifies busiest endpoint', t => {
-	const tracker = new RequestTracker();
-
-	// Add requests to different endpoints
-	// Use more unique endpoints to avoid conflicts with test defaults
-	for (let i = 0; i < 5; i++) {
-		const requestId = tracker.startRequest(
-			createTestRequestMetadata({
-				endpoint: '/api/users',
-				url: '/api/users', // Ensure URL is also set
-			}),
-		);
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	for (let i = 0; i < 3; i++) {
-		const requestId = tracker.startRequest(
-			createTestRequestMetadata({
-				endpoint: '/api/posts',
-				url: '/api/posts',
-			}),
-		);
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	for (let i = 0; i < 2; i++) {
-		const requestId = tracker.startRequest(
-			createTestRequestMetadata({
-				endpoint: '/api/comments',
-				url: '/api/comments',
-			}),
-		);
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	const stats = tracker.getStats();
-
-	// The busiest endpoint should be the one with most requests
-	// Since we have 5 requests to /api/users, 3 to /api/posts, and 2 to /api/comments
-	// /api/users should be the busiest
-	t.is(stats.busiestEndpoint, '/api/users');
-});
-
-test('RequestTracker getStats identifies slowest endpoint', t => {
-	const tracker = new RequestTracker();
-
-	// Add requests with different durations to different endpoints
-	// Note: Duration is calculated from actual execution time, not metadata
-	for (let i = 0; i < 3; i++) {
-		const requestId = tracker.startRequest(
-			createTestRequestMetadata({
-				url: '/api/fast',
-				endpoint: '/api/fast',
-			}),
-		);
-		// Fast endpoint - minimal delay
-		const start = Date.now();
-		while (Date.now() - start < 1) {
-			// Busy wait for 1ms
-		}
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	for (let i = 0; i < 3; i++) {
-		const requestId = tracker.startRequest(
-			createTestRequestMetadata({
-				url: '/api/slow',
-				endpoint: '/api/slow',
-			}),
-		);
-		// Slow endpoint - longer delay
-		const start = Date.now();
-		while (Date.now() - start < 10) {
-			// Busy wait for 10ms
-		}
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	const stats = tracker.getStats();
-
-	// The slowest endpoint should be the one with highest average duration
-	t.is(stats.slowestEndpoint, '/api/slow');
-});
-
-test('RequestTracker getStats identifies most error-prone endpoint', t => {
-	const tracker = new RequestTracker();
-
-	// Add successful requests to one endpoint
-	for (let i = 0; i < 8; i++) {
-		const requestId = tracker.startRequest(
-			createTestRequestMetadata({endpoint: '/api/good', url: '/api/good'}),
-		);
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	// Add mixed requests to another endpoint
-	for (let i = 0; i < 5; i++) {
-		const requestId = tracker.startRequest(
-			createTestRequestMetadata({endpoint: '/api/bad', url: '/api/bad'}),
-		);
-		if (i % 2 === 0) {
-			tracker.completeRequest(requestId, {statusCode: 200});
-		} else {
-			tracker.failRequest(requestId, new Error('Test error'));
-		}
-	}
-
-	const stats = tracker.getStats();
-
-	t.is(stats.mostErrorProneEndpoint, '/api/bad');
-});
-
-// Test memory tracking
-// ============================================================================
-
-test('RequestTracker tracks memory usage', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	const requestId = tracker.startRequest(metadata);
-	const completed = tracker.completeRequest(requestId, {statusCode: 200});
-
-	t.truthy(completed?.memoryStart);
-	t.truthy(completed?.memoryEnd);
-	t.truthy(completed?.memoryDelta);
-	t.truthy(completed);
-	if (completed && completed.memoryDelta) {
-		// Note: calculateMemoryDelta returns fields with 'Delta' suffix
-		t.true('heapUsedDelta' in completed.memoryDelta);
-		t.true('heapTotalDelta' in completed.memoryDelta);
-		t.true('externalDelta' in completed.memoryDelta);
-		t.true('rssDelta' in completed.memoryDelta);
-	}
-});
-
-test('RequestTracker getStats calculates average memory delta', t => {
-	const tracker = new RequestTracker();
-
-	// Add requests with memory usage
-	for (let i = 0; i < 3; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	const stats = tracker.getStats();
-
-	t.truthy(stats.averageMemoryDelta);
-	t.true('heapUsed' in stats.averageMemoryDelta);
-	t.true('heapTotal' in stats.averageMemoryDelta);
-	t.true('external' in stats.averageMemoryDelta);
-	t.true('rss' in (stats.averageMemoryDelta || {}));
-});
-
-// Test timeout tracking
-// ============================================================================
-
-test('RequestTracker getStats calculates timeout rate', t => {
-	const tracker = new RequestTracker();
-
-	// Add successful requests
-	for (let i = 0; i < 8; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	// Add timed out requests
-	for (let i = 0; i < 2; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.timeoutRequest(requestId, 1000);
-	}
-
-	const stats = tracker.getStats();
-
-	t.is(stats.totalRequests, 10);
-	t.is(stats.timeoutRate, 0.2); // 2 timeouts / 10 total
-});
-
-// Test request types tracking
-// ============================================================================
-
-test('RequestTracker getStats tracks requests by type', t => {
-	const tracker = new RequestTracker();
-
-	// Add different types of requests
-	const httpRequestId = tracker.startRequest(
-		createTestRequestMetadata({type: 'http'}),
-	);
-	tracker.completeRequest(httpRequestId, {statusCode: 200});
-
-	const aiRequestId = tracker.startRequest(
-		createTestRequestMetadata({type: 'ai'}),
-	);
-	tracker.completeRequest(aiRequestId, {statusCode: 200});
-
-	const mcpRequestId = tracker.startRequest(
-		createTestRequestMetadata({type: 'mcp'}),
-	);
-	tracker.completeRequest(mcpRequestId, {statusCode: 200});
-
-	const stats = tracker.getStats();
-
-	t.is(stats.requestsByType.http, 1);
-	t.is(stats.requestsByType.ai, 1);
-	t.is(stats.requestsByType.mcp, 1);
-});
-
-// Test time-based statistics
-// ============================================================================
-
-test('RequestTracker getStats calculates requests in last hour', t => {
-	const tracker = new RequestTracker();
-
-	// Add requests with current timestamp
-	for (let i = 0; i < 5; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	const stats = tracker.getStats();
-
-	t.is(stats.requestsInLastHour, 5);
-});
-
-test('RequestTracker getStats calculates requests in last day', t => {
-	const tracker = new RequestTracker();
-
-	// Add requests with current timestamp
-	for (let i = 0; i < 10; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	const stats = tracker.getStats();
-
-	t.is(stats.requestsInLastDay, 10);
-});
-
-// Test edge cases
-// ============================================================================
-
-test('RequestTracker handles empty active requests', t => {
-	const tracker = new RequestTracker();
-
-	const active = tracker.getActiveRequests();
-	t.is(active.length, 0);
-});
-
-test('RequestTracker handles empty completed requests', t => {
-	const tracker = new RequestTracker();
-
-	const recent = tracker.getRecentRequests();
-	t.is(recent.length, 0);
-});
-
-test('RequestTracker getStats handles no requests', t => {
-	const tracker = new RequestTracker();
-
-	const stats = tracker.getStats();
-
-	t.is(stats.totalRequests, 0);
-	t.is(stats.averageDuration, 0);
-	t.is(stats.errorRate, 0);
-});
-
-test('RequestTracker handles request with minimal metadata', t => {
-	const tracker = new RequestTracker();
-
-	const minimalMetadata = {
-		type: 'http' as const,
-	};
-
-	const requestId = tracker.startRequest(minimalMetadata);
-	const completed = tracker.completeRequest(requestId, {statusCode: 200});
-
-	t.truthy(completed);
-	t.is(completed?.type, 'http');
-});
-
-test('RequestTracker handles request completion without response metadata', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	const requestId = tracker.startRequest(metadata);
-	const completed = tracker.completeRequest(requestId);
-
-	t.truthy(completed);
-	t.is(completed?.status, 'success');
-});
-
-test('RequestTracker handles request failure without error metadata', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	const requestId = tracker.startRequest(metadata);
-	const failed = tracker.failRequest(requestId, new Error('Test error'));
-
-	t.truthy(failed);
-	t.is(failed?.status, 'error');
-});
-
-// Test error handling
-// ============================================================================
-
-test('RequestTracker handles invalid request ID gracefully', t => {
-	const tracker = new RequestTracker();
-
-	const completed = tracker.completeRequest('invalid-id');
-	t.falsy(completed);
-
-	const failed = tracker.failRequest('invalid-id', new Error('Test error'));
-	t.falsy(failed);
-
-	const timedOut = tracker.timeoutRequest('invalid-id', 1000);
-	t.falsy(timedOut);
-
-	const cancelled = tracker.cancelRequest('invalid-id');
-	t.falsy(cancelled);
-});
-
-test('RequestTracker handles memory calculation errors gracefully', t => {
-	const tracker = new RequestTracker();
-	const metadata = createTestRequestMetadata();
-
-	// Mock memoryUsage to throw error
-	// Skip memory usage mocking for this test to avoid MemoryUsageFn type issues
-	// The test will use real memory usage which is fine for this error handling test
-
-	const requestId = tracker.startRequest(metadata);
-	const completed = tracker.completeRequest(requestId, {statusCode: 200});
-
-	// Should still complete the request, just without memory delta
-	t.truthy(completed);
-	t.is(completed?.status, 'success');
-
-	// Restore memoryUsage
-	// No cleanup needed since we didn't mock memoryUsage
-});
-
-// Test performance characteristics
-// ============================================================================
-
-test('RequestTracker handles large number of requests efficiently', t => {
-	const tracker = new RequestTracker(1000);
-
-	// Start and complete many requests
-	for (let i = 0; i < 1000; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	const startTime = performance.now();
-	const stats = tracker.getStats();
-	const statsTime = performance.now() - startTime;
-
-	t.truthy(stats);
-	t.is(stats.totalRequests, 1000);
-	t.true(statsTime < 100); // Should be fast
-});
-
-test('RequestTracker getRecentRequests is efficient', t => {
-	const tracker = new RequestTracker();
-
-	// Complete many requests
-	for (let i = 0; i < 100; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	const startTime = performance.now();
-	const recent = tracker.getRecentRequests(10);
-	const queryTime = performance.now() - startTime;
-
-	t.is(recent.length, 10);
-	t.true(queryTime < 10); // Should be very fast
-});
-
-// Test memory management
-// ============================================================================
-
-test('RequestTracker respects maxCompletedRequests when full', t => {
-	const tracker = new RequestTracker(5);
-
-	// Fill tracker
-	for (let i = 0; i < 5; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-	}
-
-	t.is(tracker.getRecentRequests().length, 5);
-
-	// Add one more - should remove oldest
-	const requestId = tracker.startRequest(createTestRequestMetadata());
-	tracker.completeRequest(requestId, {statusCode: 200});
-
-	t.is(tracker.getRecentRequests().length, 5);
-});
-
-// Test request ID generation
-// ============================================================================
-
-test('RequestTracker generates unique request IDs', t => {
-	const tracker = new RequestTracker();
-	const ids = new Set<string>();
-
-	// Generate many request IDs
-	for (let i = 0; i < 100; i++) {
-		const requestId = tracker.startRequest(createTestRequestMetadata());
-		tracker.completeRequest(requestId, {statusCode: 200});
-		ids.add(requestId);
-	}
-
-	// All IDs should be unique
-	t.is(ids.size, 100);
-});
-
-test('RequestTracker request IDs follow expected format', t => {
-	const tracker = new RequestTracker();
-
-	const requestId = tracker.startRequest(createTestRequestMetadata());
-
-	t.true(requestId.startsWith('req_'));
-	t.true(requestId.includes('_'));
-	t.true(requestId.length > 10);
-});
-
-// Test custom data handling
-// ============================================================================
-
-test('RequestTracker preserves custom data', t => {
-	const tracker = new RequestTracker();
-	const customData = {
-		customKey: 'customValue',
-		nested: {
-			deep: 'value',
-		},
-		array: [1, 2, 3],
-	};
-
-	const requestId = tracker.startRequest(
-		createTestRequestMetadata({customData}),
-	);
-	const completed = tracker.completeRequest(requestId, {statusCode: 200});
-
-	t.truthy(completed);
-	t.deepEqual(completed?.customData, customData);
-});
-
-// Test tag handling
-// ============================================================================
-
-test('RequestTracker preserves tags', t => {
-	const tracker = new RequestTracker();
-	const tags = ['tag1', 'tag2', 'tag3'];
-
-	const requestId = tracker.startRequest(createTestRequestMetadata({tags}));
-	const completed = tracker.completeRequest(requestId, {statusCode: 200});
-
-	t.truthy(completed);
-	t.deepEqual(completed?.tags, tags);
-});
-
-// Test user and session tracking
-// ============================================================================
-
-test('RequestTracker preserves user and session information', t => {
-	const tracker = new RequestTracker();
-
-	const requestId = tracker.startRequest(
-		createTestRequestMetadata({
-			userId: 'user-123',
-			sessionId: 'session-456',
-		}),
-	);
-	const completed = tracker.completeRequest(requestId, {statusCode: 200});
-
-	t.truthy(completed);
-	t.is(completed?.userId, 'user-123');
-	t.is(completed?.sessionId, 'session-456');
-});
-
-// Test correlation context handling
-// ============================================================================
-
-test('RequestTracker preserves correlation context', t => {
-	const tracker = new RequestTracker();
-
-	const requestId = tracker.startRequest(
-		createTestRequestMetadata({
-			correlationId: 'corr-123',
-		}),
-	);
-	const completed = tracker.completeRequest(requestId, {statusCode: 200});
-
-	t.truthy(completed);
-	// Note: RequestTracker generates its own correlation IDs, so the provided
-	// correlationId is ignored and a new one is generated
-	t.truthy(completed?.correlationId);
-	t.is(completed?.correlationId.length, 32); // Standard UUID length
-});
-
-// Test retry tracking
-// ============================================================================
-
-test('RequestTracker preserves retry count', t => {
-	const tracker = new RequestTracker();
-
-	const requestId = tracker.startRequest(
-		createTestRequestMetadata({
-			retryCount: 3,
-		}),
-	);
-	const completed = tracker.completeRequest(requestId, {statusCode: 200});
-
-	t.truthy(completed);
-	t.is(completed?.retryCount, 3);
-});
-
-// Test size tracking
-// ============================================================================
-
-test('RequestTracker preserves request and response sizes', t => {
-	const tracker = new RequestTracker();
-
-	const requestId = tracker.startRequest(
-		createTestRequestMetadata({
-			requestSize: 1024,
-			responseSize: 2048,
-		}),
-	);
-	const completed = tracker.completeRequest(requestId, {statusCode: 200});
-
-	t.truthy(completed);
-	t.is(completed?.requestSize, 1024);
-	t.is(completed?.responseSize, 2048);
-});
-
-// Cleanup after tests
-// ============================================================================
-
-test.after('cleanup global request tracker', t => {
-	globalRequestTracker.clear();
-});
-
-// Additional cleanup to ensure test isolation
-test.after.always('final cleanup', t => {
-	globalRequestTracker.clear();
-});