// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT License.

import type { JSONObject } from '@phosphor/coreutils';

import * as stackTrace from 'stack-trace';

// tslint:disable-next-line: import-name

import TelemetryReporter from 'vscode-extension-telemetry/lib/telemetryReporter';

import { LanguageServerType } from '../activation/types';

import { DiagnosticCodes } from '../application/diagnostics/constants';

import { IWorkspaceService } from '../common/application/types';

import { AppinsightsKey, isTestExecution, isUnitTestExecution, PVSC_EXTENSION_ID } from '../common/constants';

import { traceError, traceInfo } from '../common/logger';

import { TerminalShellType } from '../common/terminal/types';

import { Architecture } from '../common/utils/platform';

import { StopWatch } from '../common/utils/stopWatch';

import {

JupyterCommands,

NativeKeyboardCommandTelemetry,

NativeMouseCommandTelemetry,

Telemetry,

VSCodeNativeTelemetry

} from '../datascience/constants';

import { ExportFormat } from '../datascience/export/types';

import { DebugConfigurationType } from '../debugger/extension/types';

import { ConsoleType, TriggerType } from '../debugger/types';

import { AutoSelectionRule } from '../interpreter/autoSelection/types';

import { LinterId } from '../linters/types';

import { EnvironmentType } from '../pythonEnvironments/info';

import { TestProvider } from '../testing/common/types';

import { EventName, PlatformErrors } from './constants';

import { LinterTrigger, TestTool } from './types';

// tslint:disable: no-any

/**

* Checks whether telemetry is supported.

* Its possible this function gets called within Debug Adapter, vscode isn't available in there.

* Within DA, there's a completely different way to send telemetry.

* @returns {boolean}

*/

function isTelemetrySupported(): boolean {

try {

// tslint:disable-next-line:no-require-imports

const vsc = require('vscode');

// tslint:disable-next-line:no-require-imports

const reporter = require('vscode-extension-telemetry');

return vsc !== undefined && reporter !== undefined;

} catch {

return false;

}

}

/**

* Checks if the telemetry is disabled in user settings

* @returns {boolean}

*/

export function isTelemetryDisabled(workspaceService: IWorkspaceService): boolean {

const settings = workspaceService.getConfiguration('telemetry').inspect<boolean>('enableTelemetry')!;

return settings.globalValue === false ? true : false;

}

const sharedProperties: Record<string, any> = {};

/**

* Set shared properties for all telemetry events.

*/

export function setSharedProperty<P extends ISharedPropertyMapping, E extends keyof P>(name: E, value?: P[E]): void {

const propertyName = name as string;

// Ignore such shared telemetry during unit tests.

if (isUnitTestExecution() && propertyName.startsWith('ds_')) {

return;

}

if (value === undefined) {

delete sharedProperties[propertyName];

} else {

sharedProperties[propertyName] = value;

}

}

/**

* Reset shared properties for testing purposes.

*/

export function _resetSharedProperties(): void {

for (const key of Object.keys(sharedProperties)) {

delete sharedProperties[key];

}

}

let telemetryReporter: TelemetryReporter | undefined;

function getTelemetryReporter() {

if (!isTestExecution() && telemetryReporter) {

return telemetryReporter;

}

const extensionId = PVSC_EXTENSION_ID;

// tslint:disable-next-line:no-require-imports

const extensions = (require('vscode') as typeof import('vscode')).extensions;

const extension = extensions.getExtension(extensionId)!;

const extensionVersion = extension.packageJSON.version;

// tslint:disable-next-line:no-require-imports

const reporter = require('vscode-extension-telemetry').default as typeof TelemetryReporter;

return (telemetryReporter = new reporter(extensionId, extensionVersion, AppinsightsKey, true));

}

export function clearTelemetryReporter() {

telemetryReporter = undefined;

}

export function sendTelemetryEvent<P extends IEventNamePropertyMapping, E extends keyof P>(

eventName: E,

durationMs?: Record<string, number> | number,

properties?: P[E],

ex?: Error

) {

if (isTestExecution() || !isTelemetrySupported()) {

return;

}

const reporter = getTelemetryReporter();

const measures = typeof durationMs === 'number' ? { duration: durationMs } : durationMs ? durationMs : undefined;

let customProperties: Record<string, string> = {};

let eventNameSent = eventName as string;

if (ex) {

// When sending telemetry events for exceptions no need to send custom properties.

// Else we have to review all properties every time as part of GDPR.

// Assume we have 10 events all with their own properties.

// As we have errors for each event, those properties are treated as new data items.

// Hence they need to be classified as part of the GDPR process, and thats unnecessary and onerous.

eventNameSent = 'ERROR';

customProperties = { originalEventName: eventName as string, stackTrace: serializeStackTrace(ex) };

reporter.sendTelemetryErrorEvent(eventNameSent, customProperties, measures, []);

} else {

if (properties) {

const data = properties as any;

Object.getOwnPropertyNames(data).forEach((prop) => {

if (data[prop] === undefined || data[prop] === null) {

return;

}

try {

// If there are any errors in serializing one property, ignore that and move on.

// Else nothing will be sent.

customProperties[prop] =

typeof data[prop] === 'string'

? data[prop]

: typeof data[prop] === 'object'

? 'object'

: data[prop].toString();

} catch (ex) {

traceError(`Failed to serialize ${prop} for ${eventName}`, ex);

}

});

}

// Add shared properties to telemetry props (we may overwrite existing ones).

Object.assign(customProperties, sharedProperties);

// Remove shared DS properties from core extension telemetry.

Object.keys(sharedProperties).forEach((shareProperty) => {

if (

customProperties[shareProperty] &&

shareProperty.startsWith('ds_') &&

!(eventNameSent.startsWith('DS_') || eventNameSent.startsWith('DATASCIENCE'))

) {

delete customProperties[shareProperty];

}

});

reporter.sendTelemetryEvent(eventNameSent, customProperties, measures);

}

if (process.env && process.env.VSC_PYTHON_LOG_TELEMETRY) {

traceInfo(

`Telemetry Event : ${eventNameSent} Measures: ${JSON.stringify(measures)} Props: ${JSON.stringify(

customProperties

)} `

);

}

}

// Type-parameterized form of MethodDecorator in lib.es5.d.ts.

type TypedMethodDescriptor<T> = (

target: Object,

propertyKey: string | symbol,

descriptor: TypedPropertyDescriptor<T>

) => TypedPropertyDescriptor<T> | void;

/**

* Decorates a method, sending a telemetry event with the given properties.

* @param eventName The event name to send.

* @param properties Properties to send with the event; must be valid for the event.

* @param captureDuration True if the method's execution duration should be captured.

* @param failureEventName If the decorated method returns a Promise and fails, send this event instead of eventName.

* @param lazyProperties A static function on the decorated class which returns extra properties to add to the event.

* This can be used to provide properties which are only known at runtime (after the decorator has executed).

*/

// tslint:disable-next-line:no-any function-name

export function captureTelemetry<This, P extends IEventNamePropertyMapping, E extends keyof P>(

eventName: E,

properties?: P[E],

captureDuration: boolean = true,

failureEventName?: E,

lazyProperties?: (obj: This) => P[E]

): TypedMethodDescriptor<(this: This, ...args: any[]) => any> {

// tslint:disable-next-line:no-function-expression no-any

return function (

_target: Object,

_propertyKey: string | symbol,

descriptor: TypedPropertyDescriptor<(this: This, ...args: any[]) => any>

) {

const originalMethod = descriptor.value!;

// tslint:disable-next-line:no-function-expression no-any

descriptor.value = function (this: This, ...args: any[]) {

// Legacy case; fast path that sends event before method executes.

// Does not set "failed" if the result is a Promise and throws an exception.

if (!captureDuration && !lazyProperties) {

sendTelemetryEvent(eventName, undefined, properties);

// tslint:disable-next-line:no-invalid-this

return originalMethod.apply(this, args);

}

const props = () => {

if (lazyProperties) {

return { ...properties, ...lazyProperties(this) };

}

return properties;

};

const stopWatch = captureDuration ? new StopWatch() : undefined;

// tslint:disable-next-line:no-invalid-this no-use-before-declare no-unsafe-any

const result = originalMethod.apply(this, args);

// If method being wrapped returns a promise then wait for it.

// tslint:disable-next-line:no-unsafe-any

if (result && typeof result.then === 'function' && typeof result.catch === 'function') {

// tslint:disable-next-line:prefer-type-cast

(result as Promise<void>)

.then((data) => {

sendTelemetryEvent(eventName, stopWatch?.elapsedTime, props());

return data;

})

// tslint:disable-next-line:promise-function-async

.catch((ex) => {

// tslint:disable-next-line:no-any

const failedProps: P[E] = props() || ({} as any);

(failedProps as any).failed = true;

sendTelemetryEvent(

failureEventName ? failureEventName : eventName,

stopWatch?.elapsedTime,

failedProps,

ex

);

});

} else {

sendTelemetryEvent(eventName, stopWatch?.elapsedTime, props());

}

return result;

};

return descriptor;

};

}

// function sendTelemetryWhenDone<T extends IDSMappings, K extends keyof T>(eventName: K, properties?: T[K]);

export function sendTelemetryWhenDone<P extends IEventNamePropertyMapping, E extends keyof P>(

eventName: E,

promise: Promise<any> | Thenable<any>,

stopWatch?: StopWatch,

properties?: P[E]

) {

stopWatch = stopWatch ? stopWatch : new StopWatch();

if (typeof promise.then === 'function') {

// tslint:disable-next-line:prefer-type-cast no-any

(promise as Promise<any>).then(

(data) => {

// tslint:disable-next-line:no-non-null-assertion

sendTelemetryEvent(eventName, stopWatch!.elapsedTime, properties);

return data;

// tslint:disable-next-line:promise-function-async

},

(ex) => {

// tslint:disable-next-line:no-non-null-assertion

sendTelemetryEvent(eventName, stopWatch!.elapsedTime, properties, ex);

return Promise.reject(ex);

}

);

} else {

throw new Error('Method is neither a Promise nor a Theneable');

}

}

function serializeStackTrace(ex: Error): string {

// We aren't showing the error message (ex.message) since it might contain PII.

let trace = '';

for (const frame of stackTrace.parse(ex)) {

const filename = frame.getFileName();

if (filename) {

const lineno = frame.getLineNumber();

const colno = frame.getColumnNumber();

trace += `\n\tat ${getCallsite(frame)} ${filename}:${lineno}:${colno}`;

} else {

trace += '\n\tat <anonymous>';

}

}

// Ensure we always use `/` as path separators.

// This way stack traces (with relative paths) coming from different OS will always look the same.

return trace.trim().replace(/\\/g, '/');

}

function getCallsite(frame: stackTrace.StackFrame) {

const parts: string[] = [];

if (typeof frame.getTypeName() === 'string' && frame.getTypeName().length > 0) {

parts.push(frame.getTypeName());

}

if (typeof frame.getMethodName() === 'string' && frame.getMethodName().length > 0) {

parts.push(frame.getMethodName());

}

if (typeof frame.getFunctionName() === 'string' && frame.getFunctionName().length > 0) {

if (parts.length !== 2 || parts.join('.') !== frame.getFunctionName()) {

parts.push(frame.getFunctionName());

}

}

return parts.join('.');

}

/**

* Map all shared properties to their data types.

*/

export interface ISharedPropertyMapping {

/**

* For every DS telemetry we would like to know the type of Notebook Editor used when doing something.

*/

['ds_notebookeditor']: undefined | 'old' | 'custom' | 'native';

/**

* For every telemetry event from the extension we want to make sure we can associate it with install

* source. We took this approach to work around very limiting query performance issues.

*/

['installSource']: undefined | 'marketPlace' | 'pythonCodingPack';

}

// Map all events to their properties

export interface IEventNamePropertyMapping {

/**

* Telemetry event sent when providing completion items for the given position and document.

*/

[EventName.COMPLETION]: never | undefined;

/**

* Telemetry event sent with details 'python.autoComplete.addBrackets' setting

*/

[EventName.COMPLETION_ADD_BRACKETS]: {

/**

* Carries boolean `true` if 'python.autoComplete.addBrackets' is set to true, `false` otherwise

*/

enabled: boolean;

};

/**

* Telemetry event captured when debug adapter executable is created

*/

[EventName.DEBUG_ADAPTER_USING_WHEELS_PATH]: {

/**

* Carries boolean

* - `true` if path used for the adapter is the debugger with wheels.

* - `false` if path used for the adapter is the source only version of the debugger.

*/

usingWheels: boolean;

};

/**

* Telemetry captured before starting debug session.

*/

[EventName.DEBUG_SESSION_START]: {

/**

* Trigger for starting the debugger.

* - `launch`: Launch/start new code and debug it.

* - `attach`: Attach to an exiting python process (remote debugging).

* - `test`: Debugging python tests.

*

* @type {TriggerType}

*/

trigger: TriggerType;

/**

* Type of console used.

* -`internalConsole`: Use VS Code debug console (no shells/terminals).

* - `integratedTerminal`: Use VS Code terminal.

* - `externalTerminal`: Use an External terminal.

*

* @type {ConsoleType}

*/

console?: ConsoleType;

};

/**

* Telemetry captured when debug session runs into an error.

*/

[EventName.DEBUG_SESSION_ERROR]: {

/**

* Trigger for starting the debugger.

* - `launch`: Launch/start new code and debug it.

* - `attach`: Attach to an exiting python process (remote debugging).

* - `test`: Debugging python tests.

*

* @type {TriggerType}

*/

trigger: TriggerType;

/**

* Type of console used.

* -`internalConsole`: Use VS Code debug console (no shells/terminals).

* - `integratedTerminal`: Use VS Code terminal.

* - `externalTerminal`: Use an External terminal.

*

* @type {ConsoleType}

*/

console?: ConsoleType;

};

/**

* Telemetry captured after stopping debug session.

*/

[EventName.DEBUG_SESSION_STOP]: {

/**

* Trigger for starting the debugger.

* - `launch`: Launch/start new code and debug it.

* - `attach`: Attach to an exiting python process (remote debugging).

* - `test`: Debugging python tests.

*

* @type {TriggerType}

*/

trigger: TriggerType;

/**

* Type of console used.

* -`internalConsole`: Use VS Code debug console (no shells/terminals).

* - `integratedTerminal`: Use VS Code terminal.

* - `externalTerminal`: Use an External terminal.

*

* @type {ConsoleType}

*/

console?: ConsoleType;

};

/**

* Telemetry captured when user code starts running after loading the debugger.

*/

[EventName.DEBUG_SESSION_USER_CODE_RUNNING]: {

/**

* Trigger for starting the debugger.

* - `launch`: Launch/start new code and debug it.

* - `attach`: Attach to an exiting python process (remote debugging).

* - `test`: Debugging python tests.

*

* @type {TriggerType}

*/

trigger: TriggerType;

/**

* Type of console used.

* -`internalConsole`: Use VS Code debug console (no shells/terminals).

* - `integratedTerminal`: Use VS Code terminal.

* - `externalTerminal`: Use an External terminal.

*

* @type {ConsoleType}

*/

console?: ConsoleType;

};

/**

* Telemetry captured when starting the debugger.

*/

[EventName.DEBUGGER]: {

/**

* Trigger for starting the debugger.

* - `launch`: Launch/start new code and debug it.

* - `attach`: Attach to an exiting python process (remote debugging).

* - `test`: Debugging python tests.

*

* @type {TriggerType}

*/

trigger: TriggerType;

/**

* Type of console used.

* -`internalConsole`: Use VS Code debug console (no shells/terminals).

* - `integratedTerminal`: Use VS Code terminal.

* - `externalTerminal`: Use an External terminal.

*

* @type {ConsoleType}

*/

console?: ConsoleType;

/**

* Whether user has defined environment variables.

* Could have been defined in launch.json or the env file (defined in `settings.json`).

* Default `env file` is `.env` in the workspace folder.

*

* @type {boolean}

*/

hasEnvVars: boolean;

/**

* Whether there are any CLI arguments that need to be passed into the program being debugged.

*

* @type {boolean}

*/

hasArgs: boolean;

/**

* Whether the user is debugging `django`.

*

* @type {boolean}

*/

django: boolean;

/**

* Whether the user is debugging `flask`.

*

* @type {boolean}

*/

flask: boolean;

/**

* Whether the user is debugging `jinja` templates.

*

* @type {boolean}

*/

jinja: boolean;

/**

* Whether user is attaching to a local python program (attach scenario).

*

* @type {boolean}

*/

isLocalhost: boolean;

/**

* Whether debugging a module.

*

* @type {boolean}

*/

isModule: boolean;

/**

* Whether debugging with `sudo`.

*

* @type {boolean}

*/

isSudo: boolean;

/**

* Whether required to stop upon entry.

*

* @type {boolean}

*/

stopOnEntry: boolean;

/**

* Whether required to display return types in debugger.

*

* @type {boolean}

*/

showReturnValue: boolean;

/**

* Whether debugging `pyramid`.

*

* @type {boolean}

*/

pyramid: boolean;

/**

* Whether debugging a subprocess.

*

* @type {boolean}

*/

subProcess: boolean;

/**

* Whether debugging `watson`.

*

* @type {boolean}

*/

watson: boolean;

/**

* Whether degbugging `pyspark`.

*

* @type {boolean}

*/

pyspark: boolean;

/**

* Whether using `gevent` when debugging.

*

* @type {boolean}

*/

gevent: boolean;

/**

* Whether debugging `scrapy`.

*

* @type {boolean}

*/

scrapy: boolean;

};

/**

* Telemetry event sent when attaching to child process

*/

[EventName.DEBUGGER_ATTACH_TO_CHILD_PROCESS]: never | undefined;

/**

* Telemetry event sent when attaching to a local process.

*/

[EventName.DEBUGGER_ATTACH_TO_LOCAL_PROCESS]: never | undefined;

/**

* Telemetry sent after building configuration for debugger

*/

[EventName.DEBUGGER_CONFIGURATION_PROMPTS]: {

/**

* The type of debug configuration to build configuration for

*

* @type {DebugConfigurationType}

*/

configurationType: DebugConfigurationType;

/**

* Carries `true` if we are able to auto-detect manage.py path for Django, `false` otherwise

*

* @type {boolean}

*/

autoDetectedDjangoManagePyPath?: boolean;

/**

* Carries `true` if we are able to auto-detect .ini file path for Pyramid, `false` otherwise

*

* @type {boolean}

*/

autoDetectedPyramidIniPath?: boolean;

/**

* Carries `true` if we are able to auto-detect app.py path for Flask, `false` otherwise

*

* @type {boolean}

*/

autoDetectedFlaskAppPyPath?: boolean;

/**

* Carries `true` if user manually entered the required path for the app

* (path to `manage.py` for Django, path to `.ini` for Pyramid, path to `app.py` for Flask), `false` otherwise

*

* @type {boolean}

*/

manuallyEnteredAValue?: boolean;

};

/**

* Telemetry event sent when providing completion provider in launch.json. It is sent just *after* inserting the completion.

*/

[EventName.DEBUGGER_CONFIGURATION_PROMPTS_IN_LAUNCH_JSON]: never | undefined;

/**

* Telemetry is sent when providing definitions for python code, particularly when [go to definition](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-definition)

* and peek definition features are used.

*/

[EventName.DEFINITION]: never | undefined;

/**

* Telemetry event sent with details of actions when invoking a diagnostic command

*/

[EventName.DIAGNOSTICS_ACTION]: {

/**

* Diagnostics command executed.

* @type {string}

*/

commandName?: string;

/**

* Diagnostisc code ignored (message will not be seen again).

* @type {string}

*/

ignoreCode?: string;

/**

* Url of web page launched in browser.

* @type {string}

*/

url?: string;

/**

* Custom actions performed.

* @type {'switchToCommandPrompt'}

*/

action?: 'switchToCommandPrompt';

};

/**

* Telemetry event sent when we are checking if we can handle the diagnostic code

*/

[EventName.DIAGNOSTICS_MESSAGE]: {

/**

* Code of diagnostics message detected and displayed.

* @type {string}

*/

code: DiagnosticCodes;

};

/**

* Telemetry event sent with details just after editor loads

*/

[EventName.EDITOR_LOAD]: {

/**

* The conda version if selected

*/

condaVersion: string | undefined;

/**

* The python interpreter version if selected

*/

pythonVersion: string | undefined;

/**

* The type of interpreter (conda, virtualenv, pipenv etc.)

*/

interpreterType: EnvironmentType | undefined;

/**

* The type of terminal shell created: powershell, cmd, zsh, bash etc.

*

* @type {TerminalShellType}

*/

terminal: TerminalShellType;

/**

* Number of workspace folders opened

*/

workspaceFolderCount: number;

/**

* If interpreters found for the main workspace contains a python3 interpreter

*/

hasPython3: boolean;

/**

* If user has defined an interpreter in settings.json

*/

usingUserDefinedInterpreter: boolean;

/**

* If interpreter is auto selected for the workspace

*/

usingAutoSelectedWorkspaceInterpreter: boolean;

/**

* If global interpreter is being used

*/

usingGlobalInterpreter: boolean;

};

/**

* Telemetry event sent when substituting Environment variables to calculate value of variables

*/

[EventName.ENVFILE_VARIABLE_SUBSTITUTION]: never | undefined;

/**

* Telemetry event sent when an environment file is detected in the workspace.

*/

[EventName.ENVFILE_WORKSPACE]: {

/**

* If there's a custom path specified in the python.envFile workspace settings.

*/

hasCustomEnvPath: boolean;

};

/**

* Telemetry Event sent when user sends code to be executed in the terminal.

*

*/

[EventName.EXECUTION_CODE]: {

/**

* Whether the user executed a file in the terminal or just the selected text.

*

* @type {('file' | 'selection')}

*/

scope: 'file' | 'selection';

/**

* How was the code executed (through the command or by clicking the `Run File` icon).

*

* @type {('command' | 'icon')}

*/

trigger?: 'command' | 'icon';

};

/**

* Telemetry Event sent when user executes code against Django Shell.

* Values sent:

* scope

*

*/

[EventName.EXECUTION_DJANGO]: {

/**

* If `file`, then the file was executed in the django shell.

* If `selection`, then the selected text was sent to the django shell.

*

* @type {('file' | 'selection')}

*/

scope: 'file' | 'selection';

};

/**

* Telemetry event sent with details when formatting a document

*/

[EventName.FORMAT]: {

/**

* Tool being used to format

*/

tool: 'autopep8' | 'black' | 'yapf';

/**

* If arguments for formatter is provided in resource settings

*/

hasCustomArgs: boolean;

/**

* Carries `true` when formatting a selection of text, `false` otherwise

*/

formatSelection: boolean;

};

/**

* Telemetry event sent with the value of setting 'Format on type'

*/

[EventName.FORMAT_ON_TYPE]: {

/**

* Carries `true` if format on type is enabled, `false` otherwise

*

* @type {boolean}

*/

enabled: boolean;

};

/**

* Telemetry event sent when sorting imports using formatter

*/

[EventName.FORMAT_SORT_IMPORTS]: never | undefined;

/**

* Telemetry event sent when Go to Python object command is executed

*/

[EventName.GO_TO_OBJECT_DEFINITION]: never | undefined;

/**

* Telemetry event sent when providing a hover for the given position and document for interactive window using Jedi.

*/

[EventName.HOVER_DEFINITION]: never | undefined;

/**

* Telemetry event sent with details when tracking imports

*/

[EventName.HASHED_PACKAGE_NAME]: {

/**

* Hash of the package name

*

* @type {string}

*/

hashedName: string;

};

[Telemetry.HashedCellOutputMimeTypePerf]: never | undefined;

[Telemetry.HashedNotebookCellOutputMimeTypePerf]: never | undefined;

[Telemetry.HashedCellOutputMimeType]: {

/**

* Hash of the cell output mimetype

*

* @type {string}

*/

hashedName: string;

hasText: boolean;

hasLatex: boolean;

hasHtml: boolean;

hasSvg: boolean;

hasXml: boolean;

hasJson: boolean;

hasImage: boolean;

hasGeo: boolean;

hasPlotly: boolean;

hasVega: boolean;

hasWidget: boolean;

hasJupyter: boolean;

hasVnd: boolean;

};

[EventName.HASHED_PACKAGE_PERF]: never | undefined;

/**

* Telemetry event sent with details of selection in prompt

* `Prompt message` :- 'Linter ${productName} is not installed'

*/

[EventName.LINTER_NOT_INSTALLED_PROMPT]: {

/**

* Name of the linter

*

* @type {LinterId}

*/

tool?: LinterId;

/**

* `select` When 'Select linter' option is selected

* `disablePrompt` When 'Do not show again' option is selected

* `install` When 'Install' option is selected

*

* @type {('select' | 'disablePrompt' | 'install')}

*/

action: 'select' | 'disablePrompt' | 'install';

};

/**

* Telemetry event sent when installing modules

*/

[EventName.PYTHON_INSTALL_PACKAGE]: {

/**

* The name of the module. (pipenv, Conda etc.)

*

* @type {string}

*/

installer: string;

};

/**

* Telemetry sent with details immediately after linting a document completes

*/

[EventName.LINTING]: {

/**

* Name of the linter being used

*

* @type {LinterId}

*/

tool: LinterId;

/**

* If custom arguments for linter is provided in settings.json

*

* @type {boolean}

*/

hasCustomArgs: boolean;

/**

* Carries the source which triggered configuration of tests

*

* @type {LinterTrigger}

*/

trigger: LinterTrigger;

/**

* Carries `true` if linter executable is specified, `false` otherwise

*

* @type {boolean}

*/

executableSpecified: boolean;

};

/**

* Telemetry event sent after fetching the OS version

*/

[EventName.PLATFORM_INFO]: {

/**

* If fetching OS version fails, list the failure type

*

* @type {PlatformErrors}

*/

failureType?: PlatformErrors;

/**

* The OS version of the platform

*

* @type {string}

*/

osVersion?: string;

};

/**

* Telemetry is sent with details about the play run file icon

*/

[EventName.PLAY_BUTTON_ICON_DISABLED]: {

/**

* Carries `true` if play button icon is not shown (because code runner is installed), `false` otherwise

*/

disabled: boolean;

};

/**

* Telemetry event sent when 'Select Interpreter' command is invoked.

*/

[EventName.SELECT_INTERPRETER]: never | undefined;

/**

* Telemetry event sent when 'Enter interpreter path' button is clicked.

*/

[EventName.SELECT_INTERPRETER_ENTER_BUTTON]: never | undefined;

/**

* Telemetry event sent with details about what choice user made to input the interpreter path.

*/

[EventName.SELECT_INTERPRETER_ENTER_CHOICE]: {

/**

* Carries 'enter' if user chose to enter the path to executable.

* Carries 'browse' if user chose to browse for the path to the executable.

*/

choice: 'enter' | 'browse';

};

/**

* Telemetry event sent with details after updating the python interpreter

*/

[EventName.PYTHON_INTERPRETER]: {

/**

* Carries the source which triggered the update

*

* @type {('ui' | 'shebang' | 'load')}

*/

trigger: 'ui' | 'shebang' | 'load';

/**

* Carries `true` if updating python interpreter failed

*

* @type {boolean}

*/

failed: boolean;

/**

* The python version of the interpreter

*

* @type {string}

*/

pythonVersion?: string;

/**

* The version of pip module installed in the python interpreter

*

* @type {string}

*/

pipVersion?: string;

/**

* The bit-ness of the python interpreter represented using architecture.

*

* @type {Architecture}

*/

architecture?: Architecture;

};

[EventName.PYTHON_INTERPRETER_ACTIVATION_ENVIRONMENT_VARIABLES]: {

/**

* Carries `true` if environment variables are present, `false` otherwise

*

* @type {boolean}

*/

hasEnvVars?: boolean;

/**

* Carries `true` if fetching environment variables failed, `false` otherwise

*

* @type {boolean}

*/

failed?: boolean;

/**

* Whether the environment was activated within a terminal or not.

*

* @type {boolean}

*/

activatedInTerminal?: boolean;

/**

* Whether the environment was activated by the wrapper class.

* If `true`, this telemetry is sent by the class that wraps the two activation providers .

*

* @type {boolean}

*/

activatedByWrapper?: boolean;

};

/**