add more telemetry

StellaHuang95 · StellaHuang95 · commit 9148f5fe22a3 · 2026-03-16T16:50:39.000-07:00
diff --git a/src/common/telemetry/constants.ts b/src/common/telemetry/constants.ts
@@ -66,6 +66,22 @@ export enum EventNames {
      * - failureStage: string (which phase was in progress when the watchdog fired)
      */
     SETUP_HANG_DETECTED = 'SETUP.HANG_DETECTED',
+    /**
+     * Telemetry event for when a manager skips registration because its tool was not found.
+     * This is an expected outcome (not an error) and is distinct from MANAGER_REGISTRATION_FAILED.
+     * Properties:
+     * - managerName: string (e.g. 'conda', 'pyenv', 'pipenv', 'poetry')
+     * - reason: string ('tool_not_found')
+     */
+    MANAGER_REGISTRATION_SKIPPED = 'MANAGER_REGISTRATION.SKIPPED',
+    /**
+     * Telemetry event fired after manager registration when PET discovered environments
+     * of a kind whose corresponding manager did not register.
+     * Properties:
+     * - managerName: string (e.g. 'conda', 'pyenv', 'pipenv', 'poetry')
+     * - petEnvCount: number (how many envs PET found for that kind)
+     */
+    MANAGER_DISCOVERY_MISMATCH = 'MANAGER_DISCOVERY.MISMATCH',
 }
 
 // Map all events to their properties
@@ -283,4 +299,26 @@ export interface IEventNamePropertyMapping {
     [EventNames.SETUP_HANG_DETECTED]: {
         failureStage: string;
     };
+
+    /* __GDPR__
+        "manager_registration.skipped": {
+            "managerName": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "owner": "eleanorjboyd" },
+            "reason": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "owner": "eleanorjboyd" }
+        }
+    */
+    [EventNames.MANAGER_REGISTRATION_SKIPPED]: {
+        managerName: string;
+        reason: 'tool_not_found';
+    };
+
+    /* __GDPR__
+        "manager_discovery.mismatch": {
+            "managerName": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "owner": "eleanorjboyd" },
+            "petEnvCount": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true, "owner": "eleanorjboyd" }
+        }
+    */
+    [EventNames.MANAGER_DISCOVERY_MISMATCH]: {
+        managerName: string;
+        petEnvCount: number;
+    };
 }
diff --git a/src/extension.ts b/src/extension.ts
@@ -96,13 +96,87 @@ import { collectEnvironmentInfo, getEnvManagerAndPackageManagerConfigLevels, run
 import { EnvironmentManagers, ProjectCreators, PythonProjectManager } from './internal.api';
 import { registerSystemPythonFeatures } from './managers/builtin/main';
 import { SysPythonManager } from './managers/builtin/sysPythonManager';
-import { createNativePythonFinder, NativePythonFinder } from './managers/common/nativePythonFinder';
+import {
+    createNativePythonFinder,
+    NativePythonEnvironmentKind,
+    NativePythonFinder,
+} from './managers/common/nativePythonFinder';
 import { IDisposable } from './managers/common/types';
 import { registerCondaFeatures } from './managers/conda/main';
 import { registerPipenvFeatures } from './managers/pipenv/main';
 import { registerPoetryFeatures } from './managers/poetry/main';
 import { registerPyenvFeatures } from './managers/pyenv/main';
 
+/**
+ * Map from PET NativePythonEnvironmentKind to the manager name used in registration.
+ * Only includes kinds that have a dedicated manager (not system/venv/etc.).
+ */
+const PET_KIND_TO_MANAGER: ReadonlyMap<NativePythonEnvironmentKind, string> = new Map([
+    [NativePythonEnvironmentKind.conda, 'conda'],
+    [NativePythonEnvironmentKind.pyenv, 'pyenv'],
+    [NativePythonEnvironmentKind.pyenvVirtualEnv, 'pyenv'],
+    [NativePythonEnvironmentKind.pipenv, 'pipenv'],
+    [NativePythonEnvironmentKind.poetry, 'poetry'],
+]);
+
+/**
+ * Checks whether PET discovered environments whose corresponding manager did not register.
+ * Uses a soft (cached) refresh so it doesn't trigger additional PET work.
+ */
+async function checkPetManagerMismatch(
+    nativeFinder: NativePythonFinder,
+    envManagers: EnvironmentManagers,
+): Promise<void> {
+    const registeredIds = new Set(envManagers.managers.map((m) => m.id));
+
+    // Map manager names to their expected managerId prefix
+    const managerIdPrefixes: ReadonlyMap<string, string> = new Map([
+        ['conda', 'ms-python.python:conda'],
+        ['pyenv', 'ms-python.python:pyenv'],
+        ['pipenv', 'ms-python.python:pipenv'],
+        ['poetry', 'ms-python.python:poetry'],
+    ]);
+
+    // Group PET kinds by manager name to avoid double-counting (e.g. pyenv + pyenvVirtualEnv)
+    const kindsByManager = new Map<string, NativePythonEnvironmentKind[]>();
+    for (const [kind, managerName] of PET_KIND_TO_MANAGER) {
+        const existing = kindsByManager.get(managerName) ?? [];
+        existing.push(kind);
+        kindsByManager.set(managerName, existing);
+    }
+
+    for (const [managerName, kinds] of kindsByManager) {
+        const expectedPrefix = managerIdPrefixes.get(managerName);
+        if (!expectedPrefix) {
+            continue;
+        }
+
+        // Check if the corresponding manager registered
+        const isRegistered = Array.from(registeredIds).some((id) => id.startsWith(expectedPrefix));
+        if (isRegistered) {
+            continue;
+        }
+
+        // Manager not registered — check if PET found environments of any related kind
+        let totalPetEnvs = 0;
+        for (const kind of kinds) {
+            try {
+                const petEnvs = await nativeFinder.refresh(false, kind);
+                totalPetEnvs += petEnvs.length;
+            } catch {
+                // PET query failed — don't block post-init; skip this kind
+            }
+        }
+
+        if (totalPetEnvs > 0) {
+            sendTelemetryEvent(EventNames.MANAGER_DISCOVERY_MISMATCH, undefined, {
+                managerName,
+                petEnvCount: totalPetEnvs,
+            });
+        }
+    }
+}
+
 export async function activate(context: ExtensionContext): Promise<PythonEnvironmentApi | undefined> {
     // Only skip activation if user explicitly set useEnvironmentsExtension to false.
     // When disabled, the main Python extension handles environments instead (legacy mode).
@@ -594,6 +668,9 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
 
                 // Log discovery summary to help users troubleshoot environment detection issues
                 await logDiscoverySummary(envManagers);
+
+                // Check for PET-vs-manager mismatches (PET found envs but manager didn't register)
+                await checkPetManagerMismatch(nativeFinder, envManagers);
             } catch (postInitError) {
                 traceError('Post-initialization tasks failed:', postInitError);
             }
diff --git a/src/managers/conda/main.ts b/src/managers/conda/main.ts
@@ -1,6 +1,8 @@
 import { Disposable, LogOutputChannel } from 'vscode';
 import { PythonEnvironmentApi } from '../../api';
 import { traceInfo } from '../../common/logging';
+import { EventNames } from '../../common/telemetry/constants';
+import { sendTelemetryEvent } from '../../common/telemetry/sender';
 import { getPythonApi } from '../../features/pythonApi';
 import { PythonProjectManager } from '../../internal.api';
 import { NativePythonFinder } from '../common/nativePythonFinder';
@@ -18,25 +20,33 @@ export async function registerCondaFeatures(
 ): Promise<void> {
     const api: PythonEnvironmentApi = await getPythonApi();
 
+    let condaPath: string | undefined;
     try {
         // get Conda will return only ONE conda manager, that correlates to a single conda install
-        const condaPath: string = await getConda(nativeFinder);
-        const sourcingStatus: CondaSourcingStatus = await constructCondaSourcingStatus(condaPath);
-        traceInfo(sourcingStatus.toString());
-
-        const envManager = new CondaEnvManager(nativeFinder, api, log);
-        const packageManager = new CondaPackageManager(api, log);
-
-        envManager.sourcingInformation = sourcingStatus;
-
-        disposables.push(
-            envManager,
-            packageManager,
-            api.registerEnvironmentManager(envManager),
-            api.registerPackageManager(packageManager),
-        );
+        condaPath = await getConda(nativeFinder);
     } catch (ex) {
         traceInfo('Conda not found, turning off conda features.', ex);
+        sendTelemetryEvent(EventNames.MANAGER_REGISTRATION_SKIPPED, undefined, {
+            managerName: 'conda',
+            reason: 'tool_not_found',
+        });
         await notifyMissingManagerIfDefault('ms-python.python:conda', projectManager, api);
+        return;
     }
+
+    // Conda was found — errors below are real registration failures (let safeRegister handle them)
+    const sourcingStatus: CondaSourcingStatus = await constructCondaSourcingStatus(condaPath);
+    traceInfo(sourcingStatus.toString());
+
+    const envManager = new CondaEnvManager(nativeFinder, api, log);
+    const packageManager = new CondaPackageManager(api, log);
+
+    envManager.sourcingInformation = sourcingStatus;
+
+    disposables.push(
+        envManager,
+        packageManager,
+        api.registerEnvironmentManager(envManager),
+        api.registerPackageManager(packageManager),
+    );
 }
diff --git a/src/managers/pipenv/main.ts b/src/managers/pipenv/main.ts
@@ -1,6 +1,8 @@
 import { Disposable } from 'vscode';
 import { PythonEnvironmentApi } from '../../api';
 import { traceInfo } from '../../common/logging';
+import { EventNames } from '../../common/telemetry/constants';
+import { sendTelemetryEvent } from '../../common/telemetry/sender';
 import { getPythonApi } from '../../features/pythonApi';
 import { PythonProjectManager } from '../../internal.api';
 import { NativePythonFinder } from '../common/nativePythonFinder';
@@ -35,6 +37,10 @@ export async function registerPipenvFeatures(
             traceInfo(
                 'Pipenv not found, turning off pipenv features. If you have pipenv installed in a non-standard location, set the "python.pipenvPath" setting.',
             );
+            sendTelemetryEvent(EventNames.MANAGER_REGISTRATION_SKIPPED, undefined, {
+                managerName: 'pipenv',
+                reason: 'tool_not_found',
+            });
             await notifyMissingManagerIfDefault('ms-python.python:pipenv', projectManager, api);
         }
     } catch (ex) {
diff --git a/src/managers/poetry/main.ts b/src/managers/poetry/main.ts
@@ -1,6 +1,8 @@
 import { Disposable, LogOutputChannel } from 'vscode';
 import { PythonEnvironmentApi } from '../../api';
 import { traceInfo } from '../../common/logging';
+import { EventNames } from '../../common/telemetry/constants';
+import { sendTelemetryEvent } from '../../common/telemetry/sender';
 import { getPythonApi } from '../../features/pythonApi';
 import { PythonProjectManager } from '../../internal.api';
 import { NativePythonFinder } from '../common/nativePythonFinder';
@@ -36,6 +38,10 @@ export async function registerPoetryFeatures(
             );
         } else {
             traceInfo('Poetry not found, turning off poetry features.');
+            sendTelemetryEvent(EventNames.MANAGER_REGISTRATION_SKIPPED, undefined, {
+                managerName: 'poetry',
+                reason: 'tool_not_found',
+            });
             await notifyMissingManagerIfDefault('ms-python.python:poetry', projectManager, api);
         }
     } catch (ex) {
diff --git a/src/managers/pyenv/main.ts b/src/managers/pyenv/main.ts
@@ -1,6 +1,8 @@
 import { Disposable } from 'vscode';
 import { PythonEnvironmentApi } from '../../api';
 import { traceInfo } from '../../common/logging';
+import { EventNames } from '../../common/telemetry/constants';
+import { sendTelemetryEvent } from '../../common/telemetry/sender';
 import { getPythonApi } from '../../features/pythonApi';
 import { PythonProjectManager } from '../../internal.api';
 import { NativePythonFinder } from '../common/nativePythonFinder';
@@ -23,6 +25,10 @@ export async function registerPyenvFeatures(
             disposables.push(mgr, api.registerEnvironmentManager(mgr));
         } else {
             traceInfo('Pyenv not found, turning off pyenv features.');
+            sendTelemetryEvent(EventNames.MANAGER_REGISTRATION_SKIPPED, undefined, {
+                managerName: 'pyenv',
+                reason: 'tool_not_found',
+            });
             await notifyMissingManagerIfDefault('ms-python.python:pyenv', projectManager, api);
         }
     } catch (ex) {
