Improve telemetry error classification to reduce 'unknown' error types (#1409)

## Problem

The `classifyError()` function in the telemetry error classifier had
limited coverage — only 6 error categories were recognized. Many errors
from manager registration (`MANAGER_REGISTRATION_FAILED`) were falling
into the `'unknown'` bucket, making it difficult to diagnose failures
from telemetry data.

After tracing every code path that leads to
`MANAGER_REGISTRATION_FAILED` telemetry (pipenv, pyenv, poetry, conda,
system, and shellStartupVars registration), we identified 6 common error
patterns that were unclassified.

## Changes

Added 6 new error types to `DiscoveryErrorType` and corresponding
classification logic:

| New Type | What It Catches | Detection Method |
|---|---|---|
| `tool_not_found` | "Conda not found", "Python extension not found",
"Poetry executable not found" | Message pattern |
| `command_failed` | `Failed to run "conda ..."`, `Failed to run poetry
...`, `Error spawning conda: ...` | Message pattern |
| `connection_error` | PET process dies mid-request, JSON-RPC connection
closed/disposed | `instanceof rpc.ConnectionError` |
| `rpc_error` | PET returns a JSON-RPC error response (e.g., internal
error, method not found) | `instanceof rpc.ResponseError` |
| `process_crash` | PET restarting, failed after N restart attempts,
failed to create stdio streams | Message pattern |
| `already_registered` | Duplicate manager registration (race condition)
| `instanceof BaseError` |

Every message pattern is based on exact `throw new Error(...)` strings
found in the codebase — no speculative matching.

## Ordering

The check order is designed to avoid misclassification:
1. `instanceof` checks first (most reliable, no false positives)
2. `error.code` checks for Node.js errno codes
3. Message patterns from most specific to least specific (e.g., `'not
found'` is after `'json'` to avoid catching JSON validation errors)
4. Error name fallback for cancellation variants
5. `'unknown'` as final fallback

## Testing

Added 7 new test cases covering all new error types with real-world
error messages from the codebase. All 15 tests pass.

Author: StellaHuang95

src/common/telemetry/errorClassifier.ts

@@ -1,12 +1,20 @@
 import { CancellationError } from 'vscode';
+import * as rpc from 'vscode-jsonrpc/node';
 import { RpcTimeoutError } from '../../managers/common/nativePythonFinder';
+import { BaseError } from '../errors/types';
 
 export type DiscoveryErrorType =
     | 'spawn_timeout'
     | 'spawn_enoent'
     | 'permission_denied'
     | 'canceled'
     | 'parse_error'
+    | 'tool_not_found'
+    | 'command_failed'
+    | 'connection_error'
+    | 'rpc_error'
+    | 'process_crash'
+    | 'already_registered'
     | 'unknown';
 
 /**
@@ -22,6 +30,21 @@ export function classifyError(ex: unknown): DiscoveryErrorType {
         return 'spawn_timeout';
     }
 
+    // JSON-RPC connection errors (e.g., PET process died mid-request, connection closed/disposed)
+    if (ex instanceof rpc.ConnectionError) {
+        return 'connection_error';
+    }
+
+    // JSON-RPC response errors (PET returned an error response, e.g., internal error)
+    if (ex instanceof rpc.ResponseError) {
+        return 'rpc_error';
+    }
+
+    // BaseError subclasses: EnvironmentManagerAlreadyRegisteredError, PackageManagerAlreadyRegisteredError
+    if (ex instanceof BaseError) {
+        return 'already_registered';
+    }
+
     if (!(ex instanceof Error)) {
         return 'unknown';
     }
@@ -35,15 +58,34 @@ export function classifyError(ex: unknown): DiscoveryErrorType {
         return 'permission_denied';
     }
 
-    // Check message patterns
+    // Check message patterns (order matters — more specific patterns first)
     const msg = ex.message.toLowerCase();
     if (msg.includes('timed out') || msg.includes('timeout')) {
         return 'spawn_timeout';
     }
+
+    // CLI command execution failures — checked before parse_error because command args
+    // may contain words like "json" (e.g., 'Failed to run "conda info --envs --json"')
+    if (msg.includes('failed to run') || msg.includes('error spawning')) {
+        return 'command_failed';
+    }
+
     if (msg.includes('parse') || msg.includes('unexpected token') || msg.includes('json')) {
         return 'parse_error';
     }
 
+    // Tool/executable not found — e.g., "Conda not found", "Python extension not found",
+    // "Poetry executable not found"
+    if (msg.includes('not found')) {
+        return 'tool_not_found';
+    }
+
+    // PET process crash/hang recovery failures — e.g., "PET is currently restarting",
+    // "failed after 3 restart attempts", "Failed to create stdio streams for PET process"
+    if (msg.includes('restart') || msg.includes('stdio stream')) {
+        return 'process_crash';
+    }
+
     // Check error name for cancellation variants
     if (ex.name === 'CancellationError' || ex.name === 'AbortError') {
         return 'canceled';

src/test/common/telemetry/errorClassifier.unit.test.ts

@@ -1,5 +1,7 @@
 import assert from 'node:assert';
 import { CancellationError } from 'vscode';
+import * as rpc from 'vscode-jsonrpc/node';
+import { BaseError } from '../../../common/errors/types';
 import { classifyError } from '../../../common/telemetry/errorClassifier';
 import { RpcTimeoutError } from '../../../managers/common/nativePythonFinder';
 
@@ -64,5 +66,64 @@ suite('Error Classifier', () => {
         test('should classify unrecognized errors as unknown', () => {
             assert.strictEqual(classifyError(new Error('something went wrong')), 'unknown');
         });
+
+        test('should classify ConnectionError as connection_error', () => {
+            assert.strictEqual(
+                classifyError(new rpc.ConnectionError(rpc.ConnectionErrors.Closed, 'Connection closed')),
+                'connection_error',
+            );
+            assert.strictEqual(
+                classifyError(new rpc.ConnectionError(rpc.ConnectionErrors.Disposed, 'Connection disposed')),
+                'connection_error',
+            );
+        });
+
+        test('should classify ResponseError as rpc_error', () => {
+            assert.strictEqual(classifyError(new rpc.ResponseError(-32600, 'Invalid request')), 'rpc_error');
+            assert.strictEqual(classifyError(new rpc.ResponseError(-32601, 'Method not found')), 'rpc_error');
+        });
+
+        test('should classify BaseError subclasses as already_registered', () => {
+            // Using a concrete subclass to test (BaseError is abstract)
+            class TestRegisteredError extends BaseError {
+                constructor(message: string) {
+                    super('InvalidArgument', message);
+                }
+            }
+            assert.strictEqual(
+                classifyError(new TestRegisteredError('Environment manager with id test already registered')),
+                'already_registered',
+            );
+        });
+
+        test('should classify "not found" messages as tool_not_found', () => {
+            assert.strictEqual(classifyError(new Error('Conda not found')), 'tool_not_found');
+            assert.strictEqual(classifyError(new Error('Python extension not found')), 'tool_not_found');
+            assert.strictEqual(classifyError(new Error('Poetry executable not found')), 'tool_not_found');
+        });
+
+        test('should classify command execution failures as command_failed', () => {
+            assert.strictEqual(
+                classifyError(new Error('Failed to run "conda info --envs --json":\n some error')),
+                'command_failed',
+            );
+            assert.strictEqual(classifyError(new Error('Failed to run poetry install')), 'command_failed');
+            assert.strictEqual(classifyError(new Error('Error spawning conda: ENOENT')), 'command_failed');
+        });
+
+        test('should classify PET process crash/restart errors as process_crash', () => {
+            assert.strictEqual(
+                classifyError(new Error('Python Environment Tools (PET) is currently restarting. Please try again.')),
+                'process_crash',
+            );
+            assert.strictEqual(
+                classifyError(new Error('Python Environment Tools (PET) failed after 3 restart attempts.')),
+                'process_crash',
+            );
+            assert.strictEqual(
+                classifyError(new Error('Failed to create stdio streams for PET process')),
+                'process_crash',
+            );
+        });
     });
 });