update telemetry events to support envs ext (#25277)

fixes for the following events:
`execution_code"`
`environment.created"` 
`environment.creating"`
`python_interpreter_activation_for_terminal`

Author: eleanorjboyd

src/client/common/terminal/activator/index.ts

@@ -10,6 +10,8 @@ import { ITerminalActivationHandler, ITerminalActivator, ITerminalHelper, Termin
 import { BaseTerminalActivator } from './base';
 import { inTerminalEnvVarExperiment } from '../../experiments/helpers';
 import { useEnvExtension } from '../../../envExt/api.internal';
+import { EventName } from '../../../telemetry/constants';
+import { sendTelemetryEvent } from '../../../telemetry';
 
 @injectable()
 export class TerminalActivator implements ITerminalActivator {
@@ -43,6 +45,9 @@ export class TerminalActivator implements ITerminalActivator {
         const activateEnvironment =
             settings.terminal.activateEnvironment && !inTerminalEnvVarExperiment(this.experimentService);
         if (!activateEnvironment || options?.hideFromUser || useEnvExtension()) {
+            if (useEnvExtension()) {
+                sendTelemetryEvent(EventName.PYTHON_INTERPRETER_ACTIVATION_FOR_TERMINAL);
+            }
             return false;
         }
 

src/client/pythonEnvironments/creation/createEnvApi.ts

@@ -72,11 +72,28 @@ export function registerCreateEnvironmentFeatures(
             ): Promise<CreateEnvironmentResult | undefined> => {
                 if (useEnvExtension()) {
                     try {
+                        sendTelemetryEvent(EventName.ENVIRONMENT_CREATING, undefined, {
+                            environmentType: undefined,
+                            pythonVersion: undefined,
+                        });
                         const result = await executeCommand<PythonEnvironment | undefined>(
                             'python-envs.createAny',
                             options,
                         );
                         if (result) {
+                            const managerId = result.envId.managerId;
+                            if (managerId === 'ms-python.python:venv') {
+                                sendTelemetryEvent(EventName.ENVIRONMENT_CREATED, undefined, {
+                                    environmentType: 'venv',
+                                    reason: 'created',
+                                });
+                            }
+                            if (managerId === 'ms-python.python:conda') {
+                                sendTelemetryEvent(EventName.ENVIRONMENT_CREATED, undefined, {
+                                    environmentType: 'conda',
+                                    reason: 'created',
+                                });
+                            }
                             return { path: result.environmentPath.path };
                         }
                     } catch (err) {

src/client/telemetry/index.ts

@@ -2336,7 +2336,7 @@ export interface IEventNamePropertyMapping {
        }
      */
     [EventName.ENVIRONMENT_CREATING]: {
-        environmentType: 'venv' | 'conda' | 'microvenv';
+        environmentType: 'venv' | 'conda' | 'microvenv' | undefined;
         pythonVersion: string | undefined;
     };
     /**

src/client/terminals/codeExecution/codeExecutionManager.ts

@@ -41,6 +41,8 @@ export class CodeExecutionManager implements ICodeExecutionManager {
                 this.disposableRegistry.push(
                     this.commandManager.registerCommand(cmd as any, async (file: Resource) => {
                         traceVerbose(`Attempting to run Python file`, file?.fsPath);
+                        const trigger = cmd === Commands.Exec_In_Terminal ? 'command' : 'icon';
+                        const newTerminalPerFile = cmd === Commands.Exec_In_Separate_Terminal;
 
                         if (useEnvExtension()) {
                             try {
@@ -51,6 +53,11 @@ export class CodeExecutionManager implements ICodeExecutionManager {
                             sendTelemetryEvent(EventName.ENVIRONMENT_CHECK_TRIGGER, undefined, {
                                 trigger: 'run-in-terminal',
                             });
+                            sendTelemetryEvent(EventName.EXECUTION_CODE, undefined, {
+                                scope: 'file',
+                                trigger,
+                                newTerminalPerFile,
+                            });
                             return;
                         }
 
@@ -66,9 +73,9 @@ export class CodeExecutionManager implements ICodeExecutionManager {
                             trigger: 'run-in-terminal',
                         });
                         triggerCreateEnvironmentCheckNonBlocking(CreateEnvironmentCheckKind.File, file);
-                        const trigger = cmd === Commands.Exec_In_Terminal ? 'command' : 'icon';
+
                         await this.executeFileInTerminal(file, trigger, {
-                            newTerminalPerFile: cmd === Commands.Exec_In_Separate_Terminal,
+                            newTerminalPerFile,
                         })
                             .then(() => {
                                 if (this.shouldTerminalFocusOnStart(file))