Add telemetry for resolving proxies

Author: chrmarti

src/vs/workbench/api/node/proxyResolver.ts

@@ -44,8 +44,9 @@ export function connectProxyResolver(
 	const fallbackToLocalKerberos = useHostProxyDefault;
 	const loadLocalCertificates = useHostProxyDefault;
 	const isUseHostProxyEnabled = () => !isRemote || configProvider.getConfiguration('http').get<boolean>('useLocalProxyConfiguration', useHostProxyDefault);
+	const timedResolveProxy = createTimedResolveProxy(extHostWorkspace, mainThreadTelemetry);
 	const params: ProxyAgentParams = {
-		resolveProxy: url => extHostWorkspace.resolveProxy(url),
+		resolveProxy: timedResolveProxy,
 		lookupProxyAuthorization: lookupProxyAuthorization.bind(undefined, extHostWorkspace, extHostLogService, mainThreadTelemetry, configProvider, {}, {}, initData.remote.isRemote, fallbackToLocalKerberos),
 		getProxyURL: () => getExtHostConfigValue<string>(configProvider, isRemote, 'http.proxy'),
 		getProxySupport: () => getExtHostConfigValue<ProxySupportSetting>(configProvider, isRemote, 'http.proxySupport') || 'off',
@@ -240,6 +241,74 @@ function recordFetchFeatureUse(mainThreadTelemetry: MainThreadTelemetryShape, fe
 	}
 }
 
+type ProxyResolveStatsClassification = {
+	owner: 'chrmarti';
+	comment: 'Performance statistics for proxy resolution';
+	count: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'Number of proxy resolution calls' };
+	totalDuration: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'Total time spent in proxy resolution (ms)' };
+	minDuration: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'Minimum resolution time (ms)' };
+	maxDuration: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'Maximum resolution time (ms)' };
+	avgDuration: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'Average resolution time (ms)' };
+};
+
+type ProxyResolveStatsEvent = {
+	count: number;
+	totalDuration: number;
+	minDuration: number;
+	maxDuration: number;
+	avgDuration: number;
+};
+
+const proxyResolveStats = {
+	count: 0,
+	totalDuration: 0,
+	minDuration: Number.MAX_SAFE_INTEGER,
+	maxDuration: 0,
+	lastSentTime: 0,
+};
+
+const telemetryInterval = 60 * 60 * 1000; // 1 hour
+
+function sendProxyResolveStats(mainThreadTelemetry: MainThreadTelemetryShape) {
+	if (proxyResolveStats.count > 0) {
+		const avgDuration = proxyResolveStats.totalDuration / proxyResolveStats.count;
+		mainThreadTelemetry.$publicLog2<ProxyResolveStatsEvent, ProxyResolveStatsClassification>('proxyResolveStats', {
+			count: proxyResolveStats.count,
+			totalDuration: proxyResolveStats.totalDuration,
+			minDuration: proxyResolveStats.minDuration,
+			maxDuration: proxyResolveStats.maxDuration,
+			avgDuration,
+		});
+		// Reset stats after sending
+		proxyResolveStats.count = 0;
+		proxyResolveStats.totalDuration = 0;
+		proxyResolveStats.minDuration = Number.MAX_SAFE_INTEGER;
+		proxyResolveStats.maxDuration = 0;
+	}
+	proxyResolveStats.lastSentTime = Date.now();
+}
+
+function createTimedResolveProxy(extHostWorkspace: IExtHostWorkspaceProvider, mainThreadTelemetry: MainThreadTelemetryShape) {
+	return async (url: string): Promise<string | undefined> => {
+		const startTime = performance.now();
+		try {
+			return await extHostWorkspace.resolveProxy(url);
+		} finally {
+			const duration = performance.now() - startTime;
+			proxyResolveStats.count++;
+			proxyResolveStats.totalDuration += duration;
+			proxyResolveStats.minDuration = Math.min(proxyResolveStats.minDuration, duration);
+			proxyResolveStats.maxDuration = Math.max(proxyResolveStats.maxDuration, duration);
+
+			// Send telemetry if at least an hour has passed since last send
+			const now = Date.now();
+			if (now - proxyResolveStats.lastSentTime >= telemetryInterval) {
+				sendProxyResolveStats(mainThreadTelemetry);
+			}
+		}
+	};
+}
+
 function createPatchedModules(params: ProxyAgentParams, resolveProxy: ResolveProxyWithRequest) {
 
 	function mergeModules(module: any, patch: any) {