feat: implement error classification for telemetry and enhance environment discovery error handling

Author: eleanorjboyd

src/common/telemetry/errorClassifier.ts

@@ -0,0 +1,53 @@
+import { CancellationError } from 'vscode';
+import { RpcTimeoutError } from '../../managers/common/nativePythonFinder';
+
+export type DiscoveryErrorType =
+    | 'spawn_timeout'
+    | 'spawn_enoent'
+    | 'permission_denied'
+    | 'canceled'
+    | 'parse_error'
+    | 'unknown';
+
+/**
+ * Classifies an error into a telemetry-safe category for the `errorType` property.
+ * Does NOT include raw error messages (PII risk from file paths) — only the category.
+ */
+export function classifyError(ex: unknown): DiscoveryErrorType {
+    if (ex instanceof CancellationError) {
+        return 'canceled';
+    }
+
+    if (ex instanceof RpcTimeoutError) {
+        return 'spawn_timeout';
+    }
+
+    if (!(ex instanceof Error)) {
+        return 'unknown';
+    }
+
+    // Check error code for spawn failures (Node.js sets `code` on spawn errors)
+    const code = (ex as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT') {
+        return 'spawn_enoent';
+    }
+    if (code === 'EACCES' || code === 'EPERM') {
+        return 'permission_denied';
+    }
+
+    // Check message patterns
+    const msg = ex.message.toLowerCase();
+    if (msg.includes('timed out') || msg.includes('timeout')) {
+        return 'spawn_timeout';
+    }
+    if (msg.includes('parse') || msg.includes('unexpected token') || msg.includes('json')) {
+        return 'parse_error';
+    }
+
+    // Check error name for cancellation variants
+    if (ex.name === 'CancellationError' || ex.name === 'AbortError') {
+        return 'canceled';
+    }
+
+    return 'unknown';
+}

src/extension.ts

@@ -541,12 +541,19 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
                 registerInterpreterSettingsChangeListener(envManagers, projectManager, nativeFinder, api),
             );
 
-            sendTelemetryEvent(EventNames.EXTENSION_MANAGER_REGISTRATION_DURATION, start.elapsedTime);
             await terminalManager.initialize(api);
             sendManagerSelectionTelemetry(projectManager);
             await sendProjectStructureTelemetry(projectManager, envManagers);
+
+            sendTelemetryEvent(EventNames.EXTENSION_MANAGER_REGISTRATION_DURATION, start.elapsedTime);
         } catch (error) {
             traceError('Failed to initialize environment managers:', error);
+            sendTelemetryEvent(
+                EventNames.EXTENSION_MANAGER_REGISTRATION_DURATION,
+                start.elapsedTime,
+                undefined,
+                error instanceof Error ? error : undefined,
+            );
             // Show a user-friendly error message
             window.showErrorMessage(
                 l10n.t(

src/internal.api.ts

@@ -30,6 +30,7 @@ import {
 import { CreateEnvironmentNotSupported, RemoveEnvironmentNotSupported } from './common/errors/NotSupportedError';
 import { StopWatch } from './common/stopWatch';
 import { EventNames } from './common/telemetry/constants';
+import { classifyError } from './common/telemetry/errorClassifier';
 import { sendTelemetryEvent } from './common/telemetry/sender';
 
 export type EnvironmentManagerScope = undefined | string | Uri | PythonEnvironment;
@@ -213,14 +214,14 @@ export class InternalEnvironmentManager implements EnvironmentManager {
                 envCount: envs.length,
             });
         } catch (ex) {
-            const isTimeout = ex instanceof Error && ex.message.includes('timed out');
+            const errorType = classifyError(ex);
             sendTelemetryEvent(
                 EventNames.ENVIRONMENT_DISCOVERY,
                 sw.elapsedTime,
                 {
                     managerId: this.id,
-                    result: isTimeout ? 'timeout' : 'error',
-                    errorType: ex instanceof Error ? ex.name : 'unknown',
+                    result: errorType === 'canceled' || errorType === 'spawn_timeout' ? 'timeout' : 'error',
+                    errorType,
                 },
                 ex instanceof Error ? ex : undefined,
             );