Merge upstream/main: resolve conflicts keeping both logDiscoverySummary and sendEnvironmentToolUsageTelemetry

eleanorjboyd · eleanorjboyd · commit f549c7c0815c · 2026-02-27T10:35:59.000-08:00
diff --git a/src/common/pickers/environments.ts b/src/common/pickers/environments.ts
@@ -1,4 +1,4 @@
-import { ProgressLocation, QuickInputButtons, QuickPickItem, QuickPickItemKind, ThemeIcon, Uri } from 'vscode';
+import { ProgressLocation, QuickInputButtons, QuickPickItem, QuickPickItemKind, ThemeIcon, Uri, l10n } from 'vscode';
 import { CreateEnvironmentOptions, IconPath, PythonEnvironment, PythonProject } from '../../api';
 import { InternalEnvironmentManager } from '../../internal.api';
 import { Common, Interpreter, Pickers } from '../localize';
@@ -7,7 +7,13 @@ import { EventNames } from '../telemetry/constants';
 import { sendTelemetryEvent } from '../telemetry/sender';
 import { isWindows } from '../utils/platformUtils';
 import { handlePythonPath } from '../utils/pythonPath';
-import { showOpenDialog, showQuickPick, showQuickPickWithButtons, withProgress } from '../window.apis';
+import {
+    showErrorMessage,
+    showOpenDialog,
+    showQuickPick,
+    showQuickPickWithButtons,
+    withProgress,
+} from '../window.apis';
 import { pickEnvironmentManager } from './managers';
 
 type QuickPickIcon =
@@ -66,6 +72,11 @@ async function browseForPython(
             return env;
         },
     );
+
+    if (!environment) {
+        showErrorMessage(l10n.t('Selected file is not a valid Python interpreter: {0}', uri.fsPath));
+    }
+
     return environment;
 }
 
diff --git a/src/common/telemetry/constants.ts b/src/common/telemetry/constants.ts
@@ -32,6 +32,14 @@ export enum EventNames {
      * - projectUnderRoot: number (count of projects nested under workspace roots)
      */
     PROJECT_STRUCTURE = 'PROJECT_STRUCTURE',
+    /**
+     * Telemetry event for environment tool usage at extension startup.
+     * Fires once per tool that has at least one project using it.
+     * Use dcount(machineId) by toolName to get unique users per tool.
+     * Properties:
+     * - toolName: string (the tool being used: venv, conda, poetry, etc.)
+     */
+    ENVIRONMENT_TOOL_USAGE = 'ENVIRONMENT_TOOL_USAGE',
     /**
      * Telemetry event for environment discovery per manager.
      * Properties:
@@ -195,6 +203,14 @@ export interface IEventNamePropertyMapping {
         projectUnderRoot: number;
     };
 
+    /* __GDPR__
+        "environment_tool_usage": {
+            "toolName": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "owner": "stellaHuang95" }
+        }
+    */
+    [EventNames.ENVIRONMENT_TOOL_USAGE]: {
+        toolName: string;
+    };
     /* __GDPR__
         "environment_discovery": {
             "managerId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "owner": "eleanorjboyd" },
diff --git a/src/common/telemetry/helpers.ts b/src/common/telemetry/helpers.ts
@@ -1,11 +1,23 @@
 import { getDefaultEnvManagerSetting, getDefaultPkgManagerSetting } from '../../features/settings/settingHelpers';
 import { EnvironmentManagers, PythonProjectManager } from '../../internal.api';
+import { getUvEnvironments } from '../../managers/builtin/uvEnvironments';
 import { ISSUES_URL } from '../constants';
-import { traceInfo, traceWarn } from '../logging';
+import { traceInfo, traceVerbose, traceWarn } from '../logging';
 import { getWorkspaceFolders } from '../workspace.apis';
 import { EventNames } from './constants';
 import { sendTelemetryEvent } from './sender';
 
+/**
+ * Extracts the base tool name from a manager ID.
+ * Example: 'ms-python.python:venv' -> 'venv'
+ * Example: 'ms-python.python:conda' -> 'conda'
+ */
+function extractToolName(managerId: string): string {
+    // Manager IDs follow the pattern 'extensionId:toolName'
+    const parts = managerId.split(':');
+    return parts.length > 1 ? parts[1].toLowerCase() : managerId.toLowerCase();
+}
+
 export function sendManagerSelectionTelemetry(pm: PythonProjectManager) {
     const ems: Set<string> = new Set();
     const ps: Set<string> = new Set();
@@ -83,6 +95,67 @@ export async function sendProjectStructureTelemetry(
     });
 }
 
+/**
+ * Sends telemetry about which environment tools are actively used across all projects.
+ * This tracks ACTUAL USAGE (which environments are set for projects), not just what's installed.
+ *
+ * Fires one event per tool that has at least one project using it.
+ * This allows simple deduplication: dcount(machineId) by toolName gives unique users per tool.
+ *
+ * Called once at extension activation to understand user's environment tool usage patterns.
+ */
+export async function sendEnvironmentToolUsageTelemetry(
+    pm: PythonProjectManager,
+    envManagers: EnvironmentManagers,
+): Promise<void> {
+    try {
+        const projects = pm.getProjects();
+
+        // Track which tools are used (Set ensures uniqueness)
+        const toolsUsed = new Set<string>();
+
+        // Lazily loaded once when a venv environment is first encountered
+        let uvEnvPaths: string[] | undefined;
+
+        // Check which environment manager is used for each project
+        for (const project of projects) {
+            try {
+                const env = await envManagers.getEnvironment(project.uri);
+                if (env?.envId?.managerId) {
+                    let toolName = extractToolName(env.envId.managerId);
+
+                    // UV environments share the venv manager. Check the persistent UV env list instead
+                    if (toolName === 'venv' && env.environmentPath) {
+                        uvEnvPaths ??= await getUvEnvironments();
+                        if (uvEnvPaths.includes(env.environmentPath.fsPath)) {
+                            toolName = 'uv';
+                        }
+                    }
+
+                    // Normalize 'global' to 'system' for consistency
+                    if (toolName === 'global') {
+                        toolName = 'system';
+                    }
+
+                    toolsUsed.add(toolName);
+                }
+            } catch {
+                // Ignore errors when getting environment for a project
+            }
+        }
+
+        // Fire one event per tool used
+        toolsUsed.forEach((tool) => {
+            sendTelemetryEvent(EventNames.ENVIRONMENT_TOOL_USAGE, undefined, {
+                toolName: tool,
+            });
+        });
+    } catch (error) {
+        // Telemetry failures must never disrupt extension activation
+        traceVerbose('Failed to send environment tool usage telemetry:', error);
+    }
+}
+
 /**
  * Logs a summary of environment discovery results after startup.
  * If no environments are found, logs guidance to help users troubleshoot.
diff --git a/src/common/utils/pythonPath.ts b/src/common/utils/pythonPath.ts
@@ -1,9 +1,8 @@
-import { Uri, Progress, CancellationToken } from 'vscode';
+import { CancellationToken, Progress, Uri } from 'vscode';
 import { PythonEnvironment } from '../../api';
 import { InternalEnvironmentManager } from '../../internal.api';
-import { traceVerbose, traceError } from '../logging';
 import { PYTHON_EXTENSION_ID } from '../constants';
-import { showErrorMessage } from '../window.apis';
+import { traceVerbose, traceWarn } from '../logging';
 
 const priorityOrder = [
     `${PYTHON_EXTENSION_ID}:pyenv`,
@@ -74,7 +73,6 @@ export async function handlePythonPath(
         }
     }
 
-    traceError(`Unable to handle ${interpreterUri.fsPath}`);
-    showErrorMessage(`Unable to handle ${interpreterUri.fsPath}`);
+    traceWarn(`Unable to handle ${interpreterUri.fsPath}`);
     return undefined;
 }
diff --git a/src/extension.ts b/src/extension.ts
@@ -19,6 +19,7 @@ import { StopWatch } from './common/stopWatch';
 import { EventNames } from './common/telemetry/constants';
 import {
     logDiscoverySummary,
+    sendEnvironmentToolUsageTelemetry,
     sendManagerSelectionTelemetry,
     sendProjectStructureTelemetry,
 } from './common/telemetry/helpers';
@@ -549,6 +550,7 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
             await terminalManager.initialize(api);
             sendManagerSelectionTelemetry(projectManager);
             await sendProjectStructureTelemetry(projectManager, envManagers);
+            await sendEnvironmentToolUsageTelemetry(projectManager, envManagers);
 
             // Log discovery summary to help users troubleshoot environment detection issues
             await logDiscoverySummary(envManagers);
diff --git a/src/features/envCommands.ts b/src/features/envCommands.ts
@@ -1,6 +1,15 @@
 import * as fs from 'fs-extra';
 import * as path from 'path';
-import { ProgressLocation, QuickInputButtons, TaskExecution, TaskRevealKind, Terminal, Uri, workspace } from 'vscode';
+import {
+    ProgressLocation,
+    QuickInputButtons,
+    TaskExecution,
+    TaskRevealKind,
+    Terminal,
+    Uri,
+    l10n,
+    workspace,
+} from 'vscode';
 import {
     CreateEnvironmentOptions,
     PythonEnvironment,
@@ -93,6 +102,10 @@ async function browseAndResolveInterpreter(
         },
     );
 
+    if (!environment) {
+        showErrorMessage(l10n.t('Selected file is not a valid Python interpreter: {0}', interpreterUri.fsPath));
+    }
+
     return environment;
 }
 
diff --git a/src/features/interpreterSelection.ts b/src/features/interpreterSelection.ts
@@ -107,20 +107,32 @@ async function resolvePriorityChainCore(
     const userInterpreterPath = getUserConfiguredSetting<string>('python', 'defaultInterpreterPath', scope);
     if (userInterpreterPath) {
         const expandedInterpreterPath = resolveVariables(userInterpreterPath, scope);
-        const resolved = await tryResolveInterpreterPath(nativeFinder, api, expandedInterpreterPath, envManagers);
-        if (resolved) {
-            traceVerbose(`${logPrefix} Priority 3: Using defaultInterpreterPath: ${userInterpreterPath}`);
-            return { result: resolved, errors };
+        if (expandedInterpreterPath.includes('${')) {
+            traceWarn(
+                `${logPrefix} defaultInterpreterPath '${userInterpreterPath}' contains unresolved variables, falling back to auto-discovery`,
+            );
+            const error: SettingResolutionError = {
+                setting: 'defaultInterpreterPath',
+                configuredValue: userInterpreterPath,
+                reason: l10n.t('Path contains unresolved variables'),
+            };
+            errors.push(error);
+        } else {
+            const resolved = await tryResolveInterpreterPath(nativeFinder, api, expandedInterpreterPath, envManagers);
+            if (resolved) {
+                traceVerbose(`${logPrefix} Priority 3: Using defaultInterpreterPath: ${userInterpreterPath}`);
+                return { result: resolved, errors };
+            }
+            const error: SettingResolutionError = {
+                setting: 'defaultInterpreterPath',
+                configuredValue: userInterpreterPath,
+                reason: `Could not resolve interpreter path '${userInterpreterPath}'`,
+            };
+            errors.push(error);
+            traceWarn(
+                `${logPrefix} defaultInterpreterPath '${userInterpreterPath}' unresolvable, falling back to auto-discovery`,
+            );
         }
-        const error: SettingResolutionError = {
-            setting: 'defaultInterpreterPath',
-            configuredValue: userInterpreterPath,
-            reason: `Could not resolve interpreter path '${userInterpreterPath}'`,
-        };
-        errors.push(error);
-        traceWarn(
-            `${logPrefix} defaultInterpreterPath '${userInterpreterPath}' unresolvable, falling back to auto-discovery`,
-        );
     }
 
     // PRIORITY 4: Auto-discovery (no user-configured settings matched)
diff --git a/src/managers/common/nativePythonFinder.ts b/src/managers/common/nativePythonFinder.ts
@@ -842,6 +842,15 @@ function getGlobalSearchPaths(): string[] {
     }
 }
 
+let workspaceSearchPathsGlobalWarningShown = false;
+
+/**
+ * @internal Test-only helper to reset the workspaceSearchPaths global-level warning flag.
+ */
+export function resetWorkspaceSearchPathsGlobalWarningFlag(): void {
+    workspaceSearchPathsGlobalWarningShown = false;
+}
+
 /**
  * Gets the most specific workspace-level setting available for workspaceSearchPaths.
  * Supports glob patterns which are expanded by PET.
@@ -851,7 +860,8 @@ function getWorkspaceSearchPaths(): string[] {
         const envConfig = getConfiguration('python-envs');
         const inspection = envConfig.inspect<string[]>('workspaceSearchPaths');
 
-        if (inspection?.globalValue) {
+        if (inspection?.globalValue && !workspaceSearchPathsGlobalWarningShown) {
+            workspaceSearchPathsGlobalWarningShown = true;
             traceError(
                 'python-envs.workspaceSearchPaths is set at the user/global level, but this setting can only be set at the workspace or workspace folder level.',
             );
diff --git a/src/test/common/pythonPath.unit.test.ts b/src/test/common/pythonPath.unit.test.ts
diff --git a/src/test/features/interpreterSelection.unit.test.ts b/src/test/features/interpreterSelection.unit.test.ts
diff --git a/src/test/managers/common/nativePythonFinder.getAllExtraSearchPaths.unit.test.ts b/src/test/managers/common/nativePythonFinder.getAllExtraSearchPaths.unit.test.ts

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,8 @@`
`1`		`-import { Uri, Progress, CancellationToken } from 'vscode';`
	`1`	`+import { CancellationToken, Progress, Uri } from 'vscode';`
`2`	`2`	`import { PythonEnvironment } from '../../api';`
`3`	`3`	`import { InternalEnvironmentManager } from '../../internal.api';`
`4`		`-import { traceVerbose, traceError } from '../logging';`
`5`	`4`	`import { PYTHON_EXTENSION_ID } from '../constants';`
`6`		`-import { showErrorMessage } from '../window.apis';`
	`5`	`+import { traceVerbose, traceWarn } from '../logging';`
`7`	`6`
`8`	`7`	`const priorityOrder = [`
`9`	`8`	`${PYTHON_EXTENSION_ID}:pyenv`,
`@@ -74,7 +73,6 @@ export async function handlePythonPath(`
`74`	`73`	`}`
`75`	`74`	`}`
`76`	`75`
`77`		- traceError(`Unable to handle ${interpreterUri.fsPath}`);
`78`		- showErrorMessage(`Unable to handle ${interpreterUri.fsPath}`);
	`76`	+ traceWarn(`Unable to handle ${interpreterUri.fsPath}`);
`79`	`77`	`return undefined;`
`80`	`78`	`}`