kristoferssolo/solorice

Fork 0

mirror of https://github.com/kristoferssolo/solorice.git synced 2025-10-21 20:10:34 +00:00

Kristofers Solo d7dddc39ef Added vscodium

2022-04-28 21:17:01 +03:00

219 KiB

Raw Blame History

Telemetry created by Jupyter Extension

Expand each section to see more information about that event.

DATASCIENCE.ADD_CELL_BELOW

Description

Data Science

Properties

No properties for event

Locations Used

src/interactive-window/commands/commandRegistry.ts#L376

        }
    }

    @captureTelemetry(Telemetry.AddCellBelow)
    private async addCellBelow(): Promise<void> {
        await this.getCurrentCodeWatcher()?.addEmptyCellToBottom();
    }

DATASCIENCE.CLICKED_EXPORT_NOTEBOOK_AS_QUICK_PICK

Description

No description provided

Properties

format: ExportFormat

Locations Used

src/interactive-window/commands/exportCommands.ts#L125

            if (pickedItem !== undefined) {
                pickedItem.handler();
            } else {
                sendTelemetryEvent(Telemetry.ClickedExportNotebookAsQuickPick);
            }
        }
    }

src/interactive-window/commands/exportCommands.ts#L141

                label: DataScience.exportPythonQuickPickLabel(),
                picked: true,
                handler: () => {
                    sendTelemetryEvent(Telemetry.ClickedExportNotebookAsQuickPick, undefined, {
                        format: ExportFormat.python
                    });
                    void this.commandManager.executeCommand(Commands.ExportAsPythonScript, sourceDocument, interpreter);

src/interactive-window/commands/exportCommands.ts#L155

                    label: DataScience.exportHTMLQuickPickLabel(),
                    picked: false,
                    handler: () => {
                        sendTelemetryEvent(Telemetry.ClickedExportNotebookAsQuickPick, undefined, {
                            format: ExportFormat.html
                        });
                        void this.commandManager.executeCommand(

src/interactive-window/commands/exportCommands.ts#L170

                    label: DataScience.exportPDFQuickPickLabel(),
                    picked: false,
                    handler: () => {
                        sendTelemetryEvent(Telemetry.ClickedExportNotebookAsQuickPick, undefined, {
                            format: ExportFormat.pdf
                        });
                        void this.commandManager.executeCommand(

DATASCIENCE.COLLAPSE_ALL

Description

No description provided

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DATASCIENCE.COPY_SOURCE

Description

No description provided

Properties

No properties for event

Locations Used

        return this.codeLenses;
    }

    @captureTelemetry(Telemetry.DebugCurrentCell)
    public async debugCurrentCell() {
        if (!this.documentManager.activeTextEditor || !this.documentManager.activeTextEditor.document) {
            return;

src/interactive-window/editor-integration/codewatcher.ts#L329

        return this.runMatchingCell(range, advance);
    }

    @captureTelemetry(Telemetry.DebugCurrentCell)
    public async debugCell(range: Range): Promise<void> {
        if (!this.documentManager.activeTextEditor || !this.documentManager.activeTextEditor.document) {
            return;

DATASCIENCE.DEBUG_FILE_INTERACTIVE

Description

No description provided

Properties

No properties for event

Locations Used

src/interactive-window/editor-integration/codewatcher.ts#L188

        return this.runFileInteractiveInternal(false);
    }

    @captureTelemetry(Telemetry.DebugFileInteractive)
    public async debugFileInteractive() {
        return this.runFileInteractiveInternal(true);
    }

DATASCIENCE.DEBUG_STEP_OVER

Description

No description provided

Properties

No properties for event

Locations Used

src/interactive-window/commands/commandRegistry.ts#L342

        }
    }

    @captureTelemetry(Telemetry.DebugStepOver)
    private async debugStepOver(): Promise<void> {
        // Make sure that we are in debug mode
        if (this.debugService.activeDebugSession) {

DATASCIENCE.DEBUG_STOP

Description

No description provided

Properties

No properties for event

Locations Used

src/interactive-window/commands/commandRegistry.ts#L350

        }
    }

    @captureTelemetry(Telemetry.DebugStop)
    private async debugStop(uri: Uri): Promise<void> {
        // Make sure that we are in debug mode
        if (this.debugService.activeDebugSession) {

DATASCIENCE.DEBUGGING.CLICKED_ON_SETUP

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/debugger/jupyter/debuggingManager.ts#L481

        );

        if (response === DataScience.setup()) {
            sendTelemetryEvent(DebuggingTelemetry.clickedOnSetup);
            this.appShell.openUrl(
                'https://github.com/microsoft/vscode-jupyter/wiki/Setting-Up-Run-by-Line-and-Debugging-for-Notebooks'
            );

DATASCIENCE.DEBUGGING.CLICKED_RUN_AND_DEBUG_CELL

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/debugger/jupyter/debuggingManager.ts#L162

            }),

            this.commandManager.registerCommand(DSCommands.RunAndDebugCell, async (cell: NotebookCell | undefined) => {
                sendTelemetryEvent(DebuggingTelemetry.clickedRunAndDebugCell);
                const editor = this.vscNotebook.activeNotebookEditor;
                if (!cell) {
                    const range = editor?.selections[0];

DATASCIENCE.DEBUGGING.CLICKED_RUNBYLINE

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/debugger/jupyter/debuggingManager.ts#L109

            }),

            this.commandManager.registerCommand(DSCommands.RunByLine, async (cell: NotebookCell | undefined) => {
                sendTelemetryEvent(DebuggingTelemetry.clickedRunByLine);
                const editor = this.vscNotebook.activeNotebookEditor;
                if (!cell) {
                    const range = editor?.selections[0];

DATASCIENCE.DEBUGGING.CLOSED_MODAL

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/debugger/jupyter/debuggingManager.ts#L486

                'https://github.com/microsoft/vscode-jupyter/wiki/Setting-Up-Run-by-Line-and-Debugging-for-Notebooks'
            );
        } else {
            sendTelemetryEvent(DebuggingTelemetry.closedModal);
        }
    }
}

DATASCIENCE.DEBUGGING.ENDED_SESSION

Description

No description provided

Properties

  reason: 'normally' | 'onKernelDisposed' | 'onAnInterrupt' | 'onARestart' | 'withKeybinding';

Locations Used

src/platform/debugger/jupyter/kernelDebugAdapter.ts#L95

                this.kernel.onDisposed(() => {
                    void debug.stopDebugging(this.session);
                    this.endSession.fire(this.session);
                    sendTelemetryEvent(DebuggingTelemetry.endedSession, undefined, { reason: 'onKernelDisposed' });
                })
            );
        }

src/platform/debugger/jupyter/kernelDebugAdapter.ts#L109

                        cellStateChange.state === NotebookCellExecutionState.Idle &&
                        !this.disconected
                    ) {
                        sendTelemetryEvent(DebuggingTelemetry.endedSession, undefined, { reason: 'normally' });
                        void this.disconnect();
                    }
                },

src/platform/debugger/jupyter/debuggingManager.ts#L153

                if (editor) {
                    const controller = this.notebookToRunByLineController.get(editor.document);
                    if (controller) {
                        sendTelemetryEvent(DebuggingTelemetry.endedSession, undefined, {
                            reason: 'withKeybinding'
                        });
                        controller.stop();

DATASCIENCE.DEBUGGING.IPYKERNEL6_STATUS

Description

No description provided

Properties

  status: 'installed' | 'notInstalled';

Locations Used

src/platform/debugger/jupyter/debuggingManager.ts#L463

            }

            const result = await isUsingIpykernel6OrLater(kernel);
            sendTelemetryEvent(DebuggingTelemetry.ipykernel6Status, undefined, {
                status: result === IpykernelCheckResult.Ok ? 'installed' : 'notInstalled'
            });
            return result;

        );
    }

    @captureTelemetry(Telemetry.DisableInteractiveShiftEnter)
    public async disableInteractiveShiftEnter(): Promise<void> {
        await this.configuration.updateSetting(
            'sendSelectionToInteractiveWindow',

src/test/datascience/shiftEnterBanner.unit.test.ts#L100


        expect(Reporter.eventNames).to.deep.equal([
            Telemetry.ShiftEnterBannerShown,
            Telemetry.DisableInteractiveShiftEnter
        ]);
    });
});

DATASCIENCE.ENABLE_INTERACTIVE_SHIFT_ENTER

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/datascience/shiftEnterBanner.ts#L104

        await this.disableBanner();
    }

    @captureTelemetry(Telemetry.EnableInteractiveShiftEnter)
    public async enableInteractiveShiftEnter(): Promise<void> {
        await this.configuration.updateSetting(
            'sendSelectionToInteractiveWindow',

src/test/datascience/shiftEnterBanner.unit.test.ts#L69


        expect(Reporter.eventNames).to.deep.equal([
            Telemetry.ShiftEnterBannerShown,
            Telemetry.EnableInteractiveShiftEnter
        ]);
    });

DATASCIENCE.EXECUTE_CELL

Description

Applies to everything (interactive+Notebooks & local+remote)

Properties

No properties for event

Locations Used

src/telemetry/telemetry.ts#L84

    properties?: P[E] & { waitBeforeSending?: Promise<void> },
    ex?: Error
) {
    if (eventName === Telemetry.ExecuteCell) {
        setSharedProperty('userExecutedCell', 'true');
    }

src/telemetry/telemetry.ts#L121

    stopWatch?: StopWatch,
    properties?: P[E] & { [waitBeforeSending]?: Promise<void> }
) {
    if (eventName === Telemetry.ExecuteCell) {
        setSharedProperty('userExecutedCell', 'true');
    }
    // eslint-disable-next-line @typescript-eslint/no-explicit-any

src/notebooks/controllers/vscodeNotebookController.ts#L255

            return;
        }
        initializeInteractiveOrNotebookTelemetryBasedOnUserAction(notebook.uri, this.connection);
        sendKernelTelemetryEvent(notebook.uri, Telemetry.ExecuteCell);
        // Notebook is trusted. Continue to execute cells
        traceInfo(`Execute Cells request ${cells.map((cell) => cell.index).join(', ')}`);
        await Promise.all(cells.map((cell) => this.executeCell(notebook, cell)));

src/kernels/kernel.ts#L197


    public async executeCell(cell: NotebookCell): Promise<NotebookCellRunState> {
        traceCellMessage(cell, `kernel.executeCell, ${getDisplayPath(cell.notebook.uri)}`);
        sendKernelTelemetryEvent(this.resourceUri, Telemetry.ExecuteCell);
        const stopWatch = new StopWatch();
        const sessionPromise = this.startNotebook().then((nb) => nb.session);
        const promise = this.kernelExecution.executeCell(sessionPromise, cell);

    public async openFile(format: ExportFormat, uri: Uri) {
        if (format === ExportFormat.python) {
            await this.openPythonFile(uri);
            sendTelemetryEvent(Telemetry.ExportNotebookAs, undefined, {
                format: format,
                successful: true,
                opened: true

src/platform/datascience/export/exportFileOpener.ts#L32

            });
        } else {
            const opened = await this.askOpenFile(uri);
            sendTelemetryEvent(Telemetry.ExportNotebookAs, undefined, {
                format: format,
                successful: true,
                opened: opened

src/platform/datascience/export/fileConverter.ts#L69

        }

        if (reporter.token.isCancellationRequested) {
            sendTelemetryEvent(Telemetry.ExportNotebookAs, undefined, { format: format, cancelled: true });
            return;
        }
    }

DATASCIENCE.EXPORT_NOTEBOOK_AS_COMMAND

Description

No description provided

Properties

format: ExportFormat

Locations Used

src/interactive-window/commands/exportCommands.ts#L110

                this.controllers.getSelectedNotebookController(sourceDocument)?.connection.interpreter ||
                this.controllers.getPreferredNotebookController(sourceDocument)?.connection.interpreter;
            if (exportMethod) {
                sendTelemetryEvent(Telemetry.ExportNotebookAsCommand, undefined, { format: exportMethod });
            }
        }

DATASCIENCE.EXPORT_NOTEBOOK_AS_FAILED

Description

No description provided

Properties

format: ExportFormat

Locations Used

src/platform/datascience/export/fileConverter.ts#L90

            await this.performExport(format, sourceDocument, target, token, candidateInterpreter);
        } catch (e) {
            traceError('Export failed', e);
            sendTelemetryEvent(Telemetry.ExportNotebookAsFailed, undefined, { format: format });

            if (format === ExportFormat.pdf) {
                traceError(localize.DataScience.exportToPDFDependencyMessage());

No properties for event

Locations Used

src/kernels/helpers.ts#L599

                    return preferredInterpreterKernelSpec;
                }
                // Telemetry to see if this happens in the real world, this should not be possible.
                sendTelemetryEvent(Telemetry.FailedToFindKernelSpecInterpreterForInteractive);
        }
    }

src/kernels/helpers.ts#L1350

            return kernelMatchingPreferredInterpreter;
        }
        // Telemetry to see if this happens in the real world, this should not be possible.
        sendTelemetryEvent(Telemetry.FailedToFindKernelSpecInterpreterForInteractive);
    }

    // If still not found, look for a match based on notebook metadata and interpreter

Event can be removed. Not referenced anywhere

DATASCIENCE.IMPORT_NOTEBOOK

Description

No description provided

Properties

scope: 'command' | 'file'

Locations Used

src/interactive-window/interactiveWindowCommandListener.ts#L370

        return this.statusProvider.waitWithStatus(promise, message, undefined, canceled);
    }

    @captureTelemetry(Telemetry.ImportNotebook, { scope: 'command' }, false)
    private async importNotebook(): Promise<void> {
        const filtersKey = localize.DataScience.importDialogFilter();
        const filtersObject: { [name: string]: string[] } = {};

src/interactive-window/interactiveWindowCommandListener.ts#L393

        }
    }

    @captureTelemetry(Telemetry.ImportNotebook, { scope: 'file' }, false)
    private async importNotebookOnFile(file: Uri): Promise<void> {
        if (file.fsPath && file.fsPath.length > 0) {
            await this.waitForStatus(

DATASCIENCE.INTERACTIVE_WINDOW_DEBUG_SETUP_CODE_FAILURE

Description

No description provided

Properties

```
  ename: string;
```
```
  evalue: string;
```

Locations Used

src/kernels/debugging/interactiveWindowDebugger.ts#L114

        executeSilently(kernel.session, this.tracingEnableCode, {
            traceErrors: true,
            traceErrorsMessage: 'Execute_request failure enabling tracing code for IW',
            telemetryName: Telemetry.InteractiveWindowDebugSetupCodeFailure
        }).ignoreErrors();
    }

src/kernels/debugging/interactiveWindowDebugger.ts#L125

        executeSilently(kernel.session, this.tracingDisableCode, {
            traceErrors: true,
            traceErrorsMessage: 'Execute_request failure disabling tracing code for IW',
            telemetryName: Telemetry.InteractiveWindowDebugSetupCodeFailure
        }).ignoreErrors();
    }

src/kernels/debugging/interactiveWindowDebugger.ts#L154

                const importResults = await executeSilently(kernel.session, this.waitForDebugClientCode, {
                    traceErrors: true,
                    traceErrorsMessage: 'Execute_request failure starting debug session for IW',
                    telemetryName: Telemetry.InteractiveWindowDebugSetupCodeFailure
                });
                if (importResults.some((item) => item.output_type === 'error')) {
                    traceWarning(`${this.debuggerPackage} not found in path.`);

src/kernels/debugging/interactiveWindowDebugger.ts#L276

                      {
                          traceErrors: true,
                          traceErrorsMessage: 'Execute_request failure appending debugger paths for IW',
                          telemetryName: Telemetry.InteractiveWindowDebugSetupCodeFailure
                      }
                  )
                : [];

src/kernels/debugging/interactiveWindowDebugger.ts#L305

            ? await executeSilently(kernel.session, this.enableDebuggerCode, {
                  traceErrors: true,
                  traceErrorsMessage: 'Execute_request failure enabling debugging for IW',
                  telemetryName: Telemetry.InteractiveWindowDebugSetupCodeFailure
              })
            : [];

DATASCIENCE.INTERRUPT

Description

No description provided

Properties

No properties for event

Locations Used

src/notebooks/execution/kernelExecution.ts#L194

        this.documentExecutions.set(document, newCellExecutionQueue);
        return newCellExecutionQueue;
    }
    @captureTelemetry(Telemetry.Interrupt)
    @captureTelemetry(Telemetry.InterruptJupyterTime)
    private async interruptExecution(
        session: IJupyterSession,

DATASCIENCE.JUPYTER_COMMAND_SEARCH

Description

No description provided

Properties

  where: 'activeInterpreter' | 'otherInterpreter' | 'path' | 'nowhere';

```
  command: JupyterCommands;
```

Locations Used

Event can be removed. Not referenced anywhere

DATASCIENCE.JUPYTER_KERNEL_API_ACCESS

Description

No description provided

Properties

```
  extensionId: string;
```
```
  allowed: 'yes' | 'no';
```

Locations Used

src/platform/api/apiAccessService.ts#L70

        const extensionPermissions = this.globalState.get<ApiExtensionInfo | undefined>(API_ACCESS_GLOBAL_KEY);
        const extensionPermission = extensionPermissions?.find((item) => item.extensionId === info.extensionId);
        if (extensionPermission) {
            sendTelemetryEvent(Telemetry.JupyterKernelApiAccess, undefined, {
                extensionId: info.extensionId,
                allowed: extensionPermission.allowed
            });

src/platform/api/apiAccessService.ts#L98

                extensionPermissions.push({ allowed: allow ? 'yes' : 'no', extensionId: info.extensionId });
                return this.globalState.update(API_ACCESS_GLOBAL_KEY, extensionPermissions);
            });
            sendTelemetryEvent(Telemetry.JupyterKernelApiAccess, undefined, {
                extensionId: info.extensionId,
                allowed: allow ? 'yes' : 'no'
            });

DATASCIENCE.JUPYTER_KERNEL_API_USAGE

Description

No description provided

Properties

```
  extensionId: string;
```

  pemUsed: keyof IExportedKernelService;

Locations Used

src/platform/api/kernelApi.ts#L70

        KernelConnectionMetadata
    >();
    public get onDidChangeKernelSpecifications(): Event<void> {
        sendTelemetryEvent(Telemetry.JupyterKernelApiUsage, undefined, {
            extensionId: this.callingExtensionId,
            pemUsed: 'onDidChangeKernelSpecifications'
        });

src/platform/api/kernelApi.ts#L78

        return this._onDidChangeKernelSpecifications.event;
    }
    public get onDidChangeKernels(): Event<void> {
        sendTelemetryEvent(Telemetry.JupyterKernelApiUsage, undefined, {
            extensionId: this.callingExtensionId,
            pemUsed: 'onDidChangeKernels'
        });

src/platform/api/kernelApi.ts#L100

        );
    }
    async getKernelSpecifications(refresh?: boolean): Promise<KernelConnectionMetadata[]> {
        sendTelemetryEvent(Telemetry.JupyterKernelApiUsage, undefined, {
            extensionId: this.callingExtensionId,
            pemUsed: 'getKernelSpecifications'
        });

src/platform/api/kernelApi.ts#L109

        return items.map((item) => this.translateKernelConnectionMetadataToExportedType(item));
    }
    async getActiveKernels(): Promise<{ metadata: KernelConnectionMetadata; notebook: NotebookDocument }[]> {
        sendTelemetryEvent(Telemetry.JupyterKernelApiUsage, undefined, {
            extensionId: this.callingExtensionId,
            pemUsed: 'getActiveKernels'
        });

src/platform/api/kernelApi.ts#L125

    getKernel(
        notebook: NotebookDocument
    ): { metadata: KernelConnectionMetadata; connection: IKernelConnectionInfo } | undefined {
        sendTelemetryEvent(Telemetry.JupyterKernelApiUsage, undefined, {
            extensionId: this.callingExtensionId,
            pemUsed: 'getKernel'
        });

src/platform/api/kernelApi.ts#L139

        }
    }
    async startKernel(spec: KernelConnectionMetadata, notebook: NotebookDocument): Promise<IKernelConnectionInfo> {
        sendTelemetryEvent(Telemetry.JupyterKernelApiUsage, undefined, {
            extensionId: this.callingExtensionId,
            pemUsed: 'startKernel'
        });

src/platform/api/kernelApi.ts#L146

        return this.startOrConnect(spec, notebook);
    }
    async connect(spec: ActiveKernel, notebook: NotebookDocument): Promise<IKernelConnectionInfo> {
        sendTelemetryEvent(Telemetry.JupyterKernelApiUsage, undefined, {
            extensionId: this.callingExtensionId,
            pemUsed: 'connect'
        });

DATASCIENCE.JUPYTER_NOT_INSTALLED_ERROR_SHOWN

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/jupyter/interpreter/jupyterInterpreterDependencyService.ts#L157

                moduleName: ProductNames.get(Product.jupyter)!,
                pythonEnvType: interpreter.envType
            });
            sendTelemetryEvent(Telemetry.JupyterNotInstalledErrorShown);
            const selection = await this.applicationShell.showErrorMessage(
                message,
                { modal: true },

DATASCIENCE.KERNEL_STARTUP_CODE_FAILURE

Description

No description provided

Properties

```
  ename: string;
```
```
  evalue: string;
```

Locations Used

src/kernels/kernel.ts#L559

            await this.executeSilently(notebook, startupCode, {
                traceErrors: true,
                traceErrorsMessage: 'Error executing jupyter extension internal startup code',
                telemetryName: Telemetry.KernelStartupCodeFailure
            });

            // Run user specified startup commands

DATASCIENCE.NATIVE.CONVERT_NOTEBOOK_TO_PYTHON

Description

No description provided

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DATASCIENCE.NATIVE.CREATE_NEW_NOTEBOOK

Description

No description provided

Properties

No properties for event

Locations Used

src/notebooks/notebookEditorProvider.ts#L30

        const nb = await this.vscodeNotebook.openNotebookDocument(file);
        await this.vscodeNotebook.showNotebookDocument(nb);
    }
    @captureTelemetry(Telemetry.CreateNewNotebook, undefined, false)
    public async createNew(options?: { contents?: string; defaultCellLanguage: string }): Promise<void> {
        // contents will be ignored
        const language = options?.defaultCellLanguage ?? PYTHON_LANGUAGE;

        }
        this.notebookOpened = true;
        void this.PreWarmDaemonPool();
        sendTelemetryEvent(Telemetry.OpenNotebookAll);

        if (!this.rawSupported.isSupported && this.extensionChecker.isPythonExtensionInstalled) {
            // Warm up our selected interpreter for the extension

// eslint-disable-next-line @typescript-eslint/no-explicit-any
function resetData(resource: Resource, eventName: string, properties: any) {
    // Once we have successfully interrupted, clear the interrupt counter.
    if (eventName === Telemetry.NotebookInterrupt) {
        let kv: Pick<IEventNamePropertyMapping, Telemetry.NotebookInterrupt>;
        const data: undefined | typeof kv[Telemetry.NotebookInterrupt] = properties;
        // Check result to determine if success.

src/telemetry/telemetry.ts#L370

function resetData(resource: Resource, eventName: string, properties: any) {
    // Once we have successfully interrupted, clear the interrupt counter.
    if (eventName === Telemetry.NotebookInterrupt) {
        let kv: Pick<IEventNamePropertyMapping, Telemetry.NotebookInterrupt>;
        const data: undefined | typeof kv[Telemetry.NotebookInterrupt] = properties;
        // Check result to determine if success.
        if (data && 'result' in data && data.result === InterruptResult.Success) {

src/telemetry/telemetry.ts#L371

    // Once we have successfully interrupted, clear the interrupt counter.
    if (eventName === Telemetry.NotebookInterrupt) {
        let kv: Pick<IEventNamePropertyMapping, Telemetry.NotebookInterrupt>;
        const data: undefined | typeof kv[Telemetry.NotebookInterrupt] = properties;
        // Check result to determine if success.
        if (data && 'result' in data && data.result === InterruptResult.Success) {
            clearInterruptCounter(resource);

src/notebooks/execution/kernelExecution.ts#L250

                // Otherwise a real error occurred.
                sendKernelTelemetryEvent(
                    this.kernel.resourceUri,
                    Telemetry.NotebookInterrupt,
                    stopWatch.elapsedTime,
                    undefined,
                    exc

src/notebooks/execution/kernelExecution.ts#L262

        })();

        return promise.then((result) => {
            sendKernelTelemetryEvent(this.kernel.resourceUri, Telemetry.NotebookInterrupt, stopWatch.elapsedTime, {
                result
            });
            return result;

DATASCIENCE.NOTEBOOK_LANGUAGE

Description

Telemetry event sent to indicate the language used in a notebook

@type { language: string } @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used

src/platform/datascience/common.ts#L171

}

export function sendNotebookOrKernelLanguageTelemetry(
    telemetryEvent: Telemetry.SwitchToExistingKernel | Telemetry.NotebookLanguage,
    language?: string
) {
    language = getTelemetrySafeLanguage(language);

DATASCIENCE.NOTEBOOK_RESTART

Description

No description provided

Properties

No properties for event

Locations Used

src/telemetry/telemetry.ts#L378

        }
    }
    // Once we have successfully restarted, clear the interrupt counter.
    if (eventName === Telemetry.NotebookRestart) {
        let kv: Pick<IEventNamePropertyMapping, Telemetry.NotebookRestart>;
        const data: undefined | typeof kv[Telemetry.NotebookRestart] = properties;
        // For restart to be successful, we should not have `failed`

src/telemetry/telemetry.ts#L379

    }
    // Once we have successfully restarted, clear the interrupt counter.
    if (eventName === Telemetry.NotebookRestart) {
        let kv: Pick<IEventNamePropertyMapping, Telemetry.NotebookRestart>;
        const data: undefined | typeof kv[Telemetry.NotebookRestart] = properties;
        // For restart to be successful, we should not have `failed`
        const failed = data && 'failed' in data ? data.failed : false;

src/telemetry/telemetry.ts#L380

    // Once we have successfully restarted, clear the interrupt counter.
    if (eventName === Telemetry.NotebookRestart) {
        let kv: Pick<IEventNamePropertyMapping, Telemetry.NotebookRestart>;
        const data: undefined | typeof kv[Telemetry.NotebookRestart] = properties;
        // For restart to be successful, we should not have `failed`
        const failed = data && 'failed' in data ? data.failed : false;
        if (!failed) {

src/kernels/kernel.ts#L306

                ? this.kernelExecution.restart(this._notebookPromise?.then((item) => item.session))
                : this.start(new DisplayOptions(false)));
            traceInfoIfCI(`Restarted ${getDisplayPath(this.notebookDocument.uri)}`);
            sendKernelTelemetryEvent(this.resourceUri, Telemetry.NotebookRestart, stopWatch.elapsedTime);
        } catch (ex) {
            traceError(`Restart failed ${getDisplayPath(this.notebookDocument.uri)}`, ex);
            this._ignoreNotebookDisposedErrors = true;

src/kernels/kernel.ts#L317

            this.restarting = undefined;
            // If we get a kernel promise failure, then restarting timed out. Just shutdown and restart the entire server.
            // Note, this code might not be necessary, as such an error is thrown only when interrupting a kernel times out.
            sendKernelTelemetryEvent(this.resourceUri, Telemetry.NotebookRestart, stopWatch.elapsedTime, undefined, ex);
            await notebook?.session.dispose().catch(noop);
            this._ignoreNotebookDisposedErrors = false;
            throw ex;

DATASCIENCE.NOTEBOOK_START

Description

No description provided

Properties

No properties for event

Locations Used

src/telemetry/telemetry.ts#L411

}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function incrementStartFailureCount(resource: Resource, eventName: any, properties: any) {
    if (eventName === Telemetry.NotebookStart) {
        let kv: Pick<IEventNamePropertyMapping, Telemetry.NotebookStart>;
        const data: undefined | typeof kv[Telemetry.NotebookStart] = properties;
        // Check start failed.

src/telemetry/telemetry.ts#L412

// eslint-disable-next-line @typescript-eslint/no-explicit-any
function incrementStartFailureCount(resource: Resource, eventName: any, properties: any) {
    if (eventName === Telemetry.NotebookStart) {
        let kv: Pick<IEventNamePropertyMapping, Telemetry.NotebookStart>;
        const data: undefined | typeof kv[Telemetry.NotebookStart] = properties;
        // Check start failed.
        if (data && 'failed' in data && data.failed) {

src/telemetry/telemetry.ts#L413

function incrementStartFailureCount(resource: Resource, eventName: any, properties: any) {
    if (eventName === Telemetry.NotebookStart) {
        let kv: Pick<IEventNamePropertyMapping, Telemetry.NotebookStart>;
        const data: undefined | typeof kv[Telemetry.NotebookStart] = properties;
        // Check start failed.
        if (data && 'failed' in data && data.failed) {
            trackKernelResourceInformation(resource, { startFailed: true });

src/kernels/jupyter/launcher/notebookProvider.ts#L91

              )
            : this.jupyterNotebookProvider.createNotebook(options);

        sendKernelTelemetryWhenDone(options.resource, Telemetry.NotebookStart, promise, undefined, {
            disableUI: options.ui.disableUI === true
        });

DATASCIENCE.OPEN_PLOT_VIEWER

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/datascience/plotting/plotViewerProvider.ts#L46

            this.currentViewer = this.serviceContainer.get<IPlotViewer>(IPlotViewer);
            this.currentViewerClosed = this.currentViewer.closed(this.closedViewer);
            this.currentViewer.removed(this.removedPlot);
            sendTelemetryEvent(Telemetry.OpenPlotViewer);
            await this.currentViewer.show();
        }

DATASCIENCE.OPENED_INTERACTIVE

Description

No description provided

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DATASCIENCE.PYTHON_VARIABLE_FETCHING_CODE_FAILURE

Description

No description provided

Properties

```
  ename: string;
```
```
  evalue: string;
```

Locations Used

src/kernels/variables/pythonVariableRequester.ts#L62

                  {
                      traceErrors: true,
                      traceErrorsMessage: 'Failure in execute_request for getDataFrameInfo',
                      telemetryName: Telemetry.PythonVariableFetchingCodeFailure
                  }
              )
            : [];

src/kernels/variables/pythonVariableRequester.ts#L93

                  {
                      traceErrors: true,
                      traceErrorsMessage: 'Failure in execute_request for getDataFrameRows',
                      telemetryName: Telemetry.PythonVariableFetchingCodeFailure
                  }
              )
            : [];

src/kernels/variables/pythonVariableRequester.ts#L126

                          {
                              traceErrors: true,
                              traceErrorsMessage: 'Failure in execute_request for getVariableProperties',
                              telemetryName: Telemetry.PythonVariableFetchingCodeFailure
                          }
                      )
                    : [];

src/kernels/variables/pythonVariableRequester.ts#L154

                      {
                          traceErrors: true,
                          traceErrorsMessage: 'Failure in execute_request for getVariableNamesAndTypesFromKernel',
                          telemetryName: Telemetry.PythonVariableFetchingCodeFailure
                      }
                  )
                : [];

src/kernels/variables/pythonVariableRequester.ts#L197

                  {
                      traceErrors: true,
                      traceErrorsMessage: 'Failure in execute_request for getFullVariable',
                      telemetryName: Telemetry.PythonVariableFetchingCodeFailure
                  }
              )
            : [];

DATASCIENCE.RECOMMENT_EXTENSION

Description

Telemetry sent when we recommend installing an extension.

Properties

  /**
   * Extension we recommended the user to install.
   */
  extensionId: string;

  /**
   * `displayed` - If prompt was displayed
   * `dismissed` - If prompt was displayed & dismissed by the user
   * `ok` - If prompt was displayed & ok clicked by the user
   * `cancel` - If prompt was displayed & cancel clicked by the user
   * `doNotShowAgain` - If prompt was displayed & doNotShowAgain clicked by the user
   */
  action: 'displayed' | 'dismissed' | 'ok' | 'cancel' | 'doNotShowAgain';

Locations Used

src/platform/datascience/extensionRecommendation.ts#L120

            `[${extensionInfo.displayName}](${extensionInfo.extensionLink})`,
            language
        );
        sendTelemetryEvent(Telemetry.RecommendExtension, undefined, { extensionId, action: 'displayed' });
        const selection = await this.appShell.showInformationMessage(
            message,
            Common.bannerLabelYes(),

src/platform/datascience/extensionRecommendation.ts#L129

        );
        switch (selection) {
            case Common.bannerLabelYes(): {
                sendTelemetryEvent(Telemetry.RecommendExtension, undefined, { extensionId, action: 'ok' });
                this.commandManager.executeCommand('extension.open', extensionId).then(noop, noop);
                break;
            }

src/platform/datascience/extensionRecommendation.ts#L134

                break;
            }
            case Common.bannerLabelNo(): {
                sendTelemetryEvent(Telemetry.RecommendExtension, undefined, { extensionId, action: 'cancel' });
                break;
            }
            case Common.doNotShowAgain(): {

src/platform/datascience/extensionRecommendation.ts#L138

                break;
            }
            case Common.doNotShowAgain(): {
                sendTelemetryEvent(Telemetry.RecommendExtension, undefined, { extensionId, action: 'doNotShowAgain' });
                const list = this.globalMemento.get<string[]>(mementoKeyToNeverPromptExtensionAgain, []);
                if (!list.includes(extensionId)) {
                    list.push(extensionId);

src/platform/datascience/extensionRecommendation.ts#L147

                break;
            }
            default:
                sendTelemetryEvent(Telemetry.RecommendExtension, undefined, { extensionId, action: 'dismissed' });
        }
    }
}

DATASCIENCE.REDO

Description

No description provided

Properties

No properties for event

Locations Used

DATASCIENCE.RUN_ALL_CELLS

Properties

No properties for event

Locations Used

src/kernels/variables/debuggerVariables.ts#L127

            // Note, full variable results isn't necessary for this call. It only really needs the variable value.
            const result = this.lastKnownVariables.find((v) => v.name === name);
            if (result && kernel?.notebookDocument.uri.fsPath.endsWith('.ipynb')) {
                sendTelemetryEvent(Telemetry.RunByLineVariableHover);
            }
            return result;
        }

DATASCIENCE.RUN_CELL

Description

No description provided

Properties

No properties for event

Locations Used

DATASCIENCE.SCROLLED_TO_CELL

Description

No description provided

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DATASCIENCE.SELECT_JUPYTER_INTERPRETER_Command

Description

Telemetry sent when user selects an interpreter to start jupyter server.

@type {(never | undefined)} @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used

src/kernels/jupyter/interpreter/jupyterInterpreterSelectionCommand.ts#L24

    public async activate(): Promise<void> {
        this.disposables.push(
            this.cmdManager.registerCommand('jupyter.selectJupyterInterpreter', () => {
                sendTelemetryEvent(Telemetry.SelectJupyterInterpreterCommand);
                this.service.selectInterpreter().ignoreErrors();
            })
        );

DATASCIENCE.SELECT_JUPYTER_URI

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/jupyter/launcher/commandLineSelector.ts#L36

        workspaceService.onDidChangeConfiguration(this.onDidChangeConfiguration.bind(this));
    }

    @captureTelemetry(Telemetry.SelectJupyterURI)
    public selectJupyterCommandLine(file: Uri): Promise<void> {
        const multiStep = this.multiStepFactory.create<{}>();
        return multiStep.run(this.startSelectingCommandLine.bind(this, file), {});

src/kernels/jupyter/serverSelector.ts#L57

        @inject(IJupyterServerUriStorage) private readonly serverUriStorage: IJupyterServerUriStorage
    ) {}

    @captureTelemetry(Telemetry.SelectJupyterURI)
    @traceDecorators.error('Failed to select Jupyter Uri')
    public selectJupyterURI(
        allowLocal: boolean,

DATASCIENCE.SELECT_LOCAL_JUPYTER_KERNEL

Description

No description provided

Properties

No properties for event

Locations Used

src/notebooks/controllers/vscodeNotebookController.ts#L571

        // Else VSC is just setting a kernel for a notebook after it has opened.
        if (existingKernel) {
            const telemetryEvent = isLocalConnection(this.kernelConnection)
                ? Telemetry.SelectLocalJupyterKernel
                : Telemetry.SelectRemoteJupyterKernel;
            sendKernelTelemetryEvent(document.uri, telemetryEvent);
            this.notebookApi.notebookEditors

DATASCIENCE.SELECT_REMOTE_JUPYTER_KERNEL

Description

No description provided

Properties

No properties for event

Locations Used

src/notebooks/controllers/vscodeNotebookController.ts#L572

        if (existingKernel) {
            const telemetryEvent = isLocalConnection(this.kernelConnection)
                ? Telemetry.SelectLocalJupyterKernel
                : Telemetry.SelectRemoteJupyterKernel;
            sendKernelTelemetryEvent(document.uri, telemetryEvent);
            this.notebookApi.notebookEditors
                .filter((editor) => editor.document === document)

DATASCIENCE.SELFCERTSMESSAGECLOSE

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/errors/errorHandler.ts#L76

                            ConfigurationTarget.Workspace
                        );
                    } else if (value === closeOption) {
                        sendTelemetryEvent(Telemetry.SelfCertsMessageClose);
                    }
                });
        } else if (err instanceof VscCancellationError || err instanceof CancellationError) {

src/platform/errors/errorHandler.ts#L181

                            ConfigurationTarget.Workspace
                        );
                    } else if (value === closeOption) {
                        sendTelemetryEvent(Telemetry.SelfCertsMessageClose);
                    }
                });
            return KernelInterpreterDependencyResponse.failed;

src/kernels/jupyter/launcher/jupyterPasswordConnect.ts#L397

                    );
                    return this.fetchFunction(url, this.addAllowUnauthorized(url, true, options));
                } else if (value === closeOption) {
                    sendTelemetryEvent(Telemetry.SelfCertsMessageClose);
                }
            }
            throw e;

DATASCIENCE.SELFCERTSMESSAGEENABLED

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/errors/errorHandler.ts#L68

                .showErrorMessage(DataScience.jupyterSelfCertFail().format(err.message), enableOption, closeOption)
                .then((value) => {
                    if (value === enableOption) {
                        sendTelemetryEvent(Telemetry.SelfCertsMessageEnabled);
                        void this.configuration.updateSetting(
                            'allowUnauthorizedRemoteConnection',
                            true,

src/platform/errors/errorHandler.ts#L173

                .showErrorMessage(DataScience.jupyterSelfCertFail().format(err.message), enableOption, closeOption)
                .then((value) => {
                    if (value === enableOption) {
                        sendTelemetryEvent(Telemetry.SelfCertsMessageEnabled);
                        void this.configuration.updateSetting(
                            'allowUnauthorizedRemoteConnection',
                            true,

src/kernels/jupyter/launcher/jupyterPasswordConnect.ts#L388

                    closeOption
                );
                if (value === enableOption) {
                    sendTelemetryEvent(Telemetry.SelfCertsMessageEnabled);
                    await this.configService.updateSetting(
                        'allowUnauthorizedRemoteConnection',
                        true,

No description provided

Properties

```
  azure: boolean;
```

Locations Used

src/kernels/jupyter/serverSelector.ts#L78

        await this.serverUriStorage.setUri(userURI);

        // Indicate setting a jupyter URI to a remote setting. Check if an azure remote or not
        sendTelemetryEvent(Telemetry.SetJupyterURIToUserSpecified, undefined, {
            azure: userURI.toLowerCase().includes('azure')
        });
    }

DATASCIENCE.SHOW_DATA_EXPLORER

Description

No description provided

Properties

rows: number | undefined;
columns: number | undefined

Locations Used

src/platform/datascience/data-viewing/dataViewer.ts#L233


        // Log telemetry about number of rows
        try {
            sendTelemetryEvent(Telemetry.ShowDataViewer, 0, {
                rows: output.rowCount ? output.rowCount : 0,
                columns: output.columns ? output.columns.length : 0
            });

src/platform/datascience/data-viewing/dataViewer.ts#L316


    private sendElapsedTimeTelemetry() {
        if (this.rowsTimer && this.pendingRowsCount === 0) {
            sendTelemetryEvent(Telemetry.ShowDataViewer, this.rowsTimer.elapsedTime);
        }
    }

DATASCIENCE.START_SHOW_DATA_EXPLORER

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/datascience/data-viewing/dataViewerFactory.ts#L41

        }
    }

    @captureTelemetry(Telemetry.StartShowDataViewer)
    public async create(dataProvider: IDataViewerDataProvider, title: string): Promise<IDataViewer> {
        let result: IDataViewer | undefined;

                }

                case DataScience.selectDifferentJupyterInterpreter(): {
                    sendTelemetryEvent(Telemetry.UserDidNotInstallJupyter);
                    return JupyterInterpreterDependencyResponse.selectAnotherInterpreter;
                }

src/kernels/jupyter/interpreter/jupyterInterpreterDependencyService.ts#L214


                case DataScience.pythonInteractiveHelpLink(): {
                    this.applicationShell.openUrl(HelpLinks.PythonInteractiveHelpLink);
                    sendTelemetryEvent(Telemetry.UserDidNotInstallJupyter);
                    return JupyterInterpreterDependencyResponse.cancel;
                }

src/kernels/jupyter/interpreter/jupyterInterpreterDependencyService.ts#L219

                }

                default:
                    sendTelemetryEvent(Telemetry.UserDidNotInstallJupyter);
                    return JupyterInterpreterDependencyResponse.cancel;
            }
        } finally {

Telemetry event sent when installing a jupyter dependency

@type {product: string} @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DATASCIENCE.USER_INSTALLED_PANDAS

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/datascience/data-viewing/dataViewerDependencyService.ts#L105

                cancellatonPromise
            ]);
            if (response === InstallerResponse.Installed) {
                sendTelemetryEvent(Telemetry.UserInstalledPandas);
            }
        } else {
            sendTelemetryEvent(Telemetry.UserDidNotInstallPandas);

DATASCIENCE.USER_STARTUP_CODE_FAILURE

Description

No description provided

Properties

```
  ename: string;
```
```
  evalue: string;
```

Locations Used

src/kernels/kernel.ts#L566

            await this.executeSilently(notebook, this.getUserStartupCommands(), {
                traceErrors: true,
                traceErrorsMessage: 'Error executing user defined startup code',
                telemetryName: Telemetry.UserStartupCodeFailure
            });
        }

DATASCIENCE.VARIABLE_EXPLORER_TOGGLE

Description

No description provided

Properties

open: boolean;
runByLine: boolean

Locations Used

src/platform/api/pythonApi.ts#L289

        }
    }
    private workspaceCachedActiveInterpreter = new Map<string, Promise<PythonEnvironment | undefined>>();
    @captureTelemetry(Telemetry.ActiveInterpreterListingPerf)
    @traceDecorators.verbose('Get Active Interpreter', TraceOptions.Arguments | TraceOptions.BeforeCall)
    public getActiveInterpreter(resource?: Uri): Promise<PythonEnvironment | undefined> {
        this.hookupOnDidChangeInterpreterEvent();

        // On shutdown send how long on average we spent parsing code lens
        if (this.totalGetCodeLensCalls > 0) {
            sendTelemetryEvent(
                Telemetry.CodeLensAverageAcquisitionTime,
                this.totalExecutionTimeInMs / this.totalGetCodeLensCalls
            );
        }

DS_INTERNAL.COMMAND_EXECUTED

Description

Telemetry sent when a command is executed.

Properties

No properties for event

Locations Used

src/platform/common/application/commandManager.ts#L37

        return commands.registerCommand(
            command,
            (...args: U) => {
                sendTelemetryEvent(Telemetry.CommandExecuted, undefined, { command: command as string });
                if (thisArg) {
                    return callback.call(thisArg, ...(args as any));
                } else {

src/platform/common/application/commandManager.ts#L71

        return commands.registerTextEditorCommand(
            command,
            (textEditor: TextEditor, edit: TextEditorEdit, ...args: any[]) => {
                sendTelemetryEvent(Telemetry.CommandExecuted, undefined, { command: command as string });
                if (thisArg) {
                    return callback.call(thisArg, textEditor, edit, ...args);
                } else {

src/platform/common/application/commandManager.ts#L102

        U extends ICommandNameArgumentTypeMapping[E]
    >(command: E, ...rest: U): Thenable<T> {
        if (!commandsToIgnore.has(command)) {
            sendTelemetryEvent(Telemetry.CommandExecuted, undefined, { command: command as string });
        }
        return commands.executeCommand<T>(command, ...rest);
    }

DS_INTERNAL.COMPLETION_TIME_FROM_JUPYTER

Description

Telemetry event sent to capture total time taken for completions list to be provided by Jupyter. This is used to compare against time taken by LS.

@type {(undefined | never)} @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.COMPLETION_TIME_FROM_LS

Description

Telemetry event sent to capture total time taken for completions list to be provided by LS. This is used to compare against time taken by Jupyter.

@type {(undefined | never)} @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used


                            // Check for the self signed certs error specifically
                            if (err.message.indexOf('reason: self signed certificate') >= 0) {
                                sendTelemetryEvent(Telemetry.ConnectRemoteSelfCertFailedJupyter);
                                throw new JupyterSelfCertsError(connection.baseUrl);
                            } else {
                                throw WrappedError.from(

DS_INTERNAL.ERROR_START_RAWKERNEL_WITHOUT_INTERPRETER

Description

Whether we've attempted to start a raw Python kernel without any interpreter information. If we don't detect such telemetry in a few months, then we can remove this along with the temporary code associated with this telemetry.

Properties

  /**
   * Indicates whether the python extension is installed.
   * If we send telemetry fro this & this is `true`, then we have a bug.
   * If its `false`, then we can ignore this telemetry.
   */
  pythonExtensionInstalled: boolean;

Locations Used

src/kernels/raw/session/hostRawNotebookProvider.ts#L115

                kernelConnection.kind === 'startUsingLocalKernelSpec'
            ) {
                if (!kernelConnection.interpreter) {
                    sendTelemetryEvent(Telemetry.AttemptedToLaunchRawKernelWithoutInterpreter, undefined, {
                        pythonExtensionInstalled: this.extensionChecker.isPythonExtensionInstalled
                    });
                }

DS_INTERNAL.EXECUTE_CELL_PERCEIVED_COLD

Description

Telemetry sent to capture first time execution of a cell. If notebook = true, this its telemetry for native editor/notebooks.

Properties

No properties for event

Locations Used

src/notebooks/execution/cellExecution.ts#L435

        const props = { notebook: true };
        if (!CellExecution.sentExecuteCellTelemetry) {
            CellExecution.sentExecuteCellTelemetry = true;
            sendTelemetryEvent(Telemetry.ExecuteCellPerceivedCold, this.stopWatchForTelemetry.elapsedTime, props);
        } else {
            sendTelemetryEvent(Telemetry.ExecuteCellPerceivedWarm, this.stopWatchForTelemetry.elapsedTime, props);
        }

src/interactive-window/editor-integration/codewatcher.ts#L1064

        if (runningStopWatch) {
            if (!CodeWatcher.sentExecuteCellTelemetry) {
                CodeWatcher.sentExecuteCellTelemetry = true;
                sendTelemetryEvent(Telemetry.ExecuteCellPerceivedCold, runningStopWatch.elapsedTime);
            } else {
                sendTelemetryEvent(Telemetry.ExecuteCellPerceivedWarm, runningStopWatch.elapsedTime);
            }

DS_INTERNAL.EXECUTE_CELL_PERCEIVED_WARM

Description

Telemetry sent to capture subsequent execution of a cell. If notebook = true, this its telemetry for native editor/notebooks.

Properties

No properties for event

Locations Used

src/notebooks/execution/cellExecution.ts#L437

            CellExecution.sentExecuteCellTelemetry = true;
            sendTelemetryEvent(Telemetry.ExecuteCellPerceivedCold, this.stopWatchForTelemetry.elapsedTime, props);
        } else {
            sendTelemetryEvent(Telemetry.ExecuteCellPerceivedWarm, this.stopWatchForTelemetry.elapsedTime, props);
        }
    }
    private canExecuteCell() {

src/interactive-window/editor-integration/codewatcher.ts#L1066

                CodeWatcher.sentExecuteCellTelemetry = true;
                sendTelemetryEvent(Telemetry.ExecuteCellPerceivedCold, runningStopWatch.elapsedTime);
            } else {
                sendTelemetryEvent(Telemetry.ExecuteCellPerceivedWarm, runningStopWatch.elapsedTime);
            }
        }
    }

DS_INTERNAL.FAILED_TO_UPDATE_JUPYTER_KERNEL_SPEC

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/jupyter/jupyterKernelService.ts#L203

            await this.fs.writeLocalFile(kernelSpecFilePath, JSON.stringify(contents, undefined, 4));
        } catch (ex) {
            // eslint-disable-next-line @typescript-eslint/no-explicit-any
            sendTelemetryEvent(Telemetry.FailedToUpdateKernelSpec, undefined, undefined, ex as any, true);
            throw ex;
        }
        if (cancelToken.isCancellationRequested) {

src/kernels/jupyter/jupyterKernelService.ts#L343

                    await this.fs.writeLocalFile(kernelSpecFilePath, JSON.stringify(specModel, undefined, 2));
                } catch (ex) {
                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                    sendTelemetryEvent(Telemetry.FailedToUpdateKernelSpec, undefined, undefined, ex as any, true);
                    throw ex;
                }
            }

DS_INTERNAL.FIND_JUPYTER_COMMAND

Description

No description provided

Properties

command: string

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.FIND_JUPYTER_KERNEL_SPEC

Description

No description provided

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.FIND_KERNEL_FOR_LOCAL_CONNECTION

Description

Telemetry event sent once done searching for kernel spec and interpreter for a local connection.

@type {{ kernelSpecFound: boolean; interpreterFound: boolean; }} @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.GET_ACTIVATED_ENV_VARIABLES

Description

Used to capture time taken to get enviornment variables for a python environment. Also lets us know whether it worked or not.

Properties

No properties for event

Locations Used

src/platform/common/process/environmentActivationService.ts#L239

        ]);

        const envType = interpreter.envType;
        sendTelemetryEvent(Telemetry.GetActivatedEnvironmentVariables, stopWatch.elapsedTime, {
            envType,
            pythonEnvType: envType,
            source: 'python',

src/platform/common/process/environmentActivationService.ts#L291

                    interpreter?.path
                )}, shell cannot be determined.`
            );
            sendTelemetryEvent(Telemetry.GetActivatedEnvironmentVariables, 0, {
                envType,
                pythonEnvType: envType,
                source: 'jupyter',

src/platform/common/process/environmentActivationService.ts#L334

                const stopWatch = new StopWatch();
                try {
                    const env = await this.getCondaEnvVariables(resource, interpreter);
                    sendTelemetryEvent(Telemetry.GetActivatedEnvironmentVariables, stopWatch.elapsedTime, {
                        envType,
                        pythonEnvType: envType,
                        source: 'jupyter',

src/platform/common/process/environmentActivationService.ts#L343

                    });
                    return env;
                } catch (ex) {
                    sendTelemetryEvent(Telemetry.GetActivatedEnvironmentVariables, stopWatch.elapsedTime, {
                        envType,
                        pythonEnvType: envType,
                        source: 'jupyter',

src/platform/common/process/environmentActivationService.ts#L387

            const processService = await processServicePromise;
            const hasCustomEnvVars = Object.keys(customEnvVars).length;
            if (!activationCommands || activationCommands.length === 0) {
                sendTelemetryEvent(Telemetry.GetActivatedEnvironmentVariables, stopWatch.elapsedTime, {
                    envType,
                    pythonEnvType: envType,
                    source: 'jupyter',

src/platform/common/process/environmentActivationService.ts#L479

            } else if (returnedEnv) {
                delete returnedEnv[PYTHON_WARNINGS];
            }
            sendTelemetryEvent(Telemetry.GetActivatedEnvironmentVariables, stopWatch.elapsedTime, {
                envType,
                pythonEnvType: envType,
                source: 'jupyter',

src/platform/common/process/environmentActivationService.ts#L489


            return returnedEnv;
        } catch (e) {
            sendTelemetryEvent(Telemetry.GetActivatedEnvironmentVariables, stopWatch.elapsedTime, {
                envType,
                pythonEnvType: envType,
                source: 'jupyter',

DS_INTERNAL.GET_PASSWORD_FAILURE

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/jupyter/launcher/jupyterPasswordConnect.ts#L258

            const requestHeaders = { Cookie: cookieString, 'X-XSRFToken': xsrfCookie };
            return { requestHeaders };
        } else {
            sendTelemetryEvent(Telemetry.GetPasswordFailure);
            return undefined;
        }
    }

DS_INTERNAL.GET_PASSWORD_SUCCESS

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/jupyter/launcher/jupyterPasswordConnect.ts#L253


        // If we found everything return it all back if not, undefined as partial is useless
        if (xsrfCookie && sessionCookieName && sessionCookieValue) {
            sendTelemetryEvent(Telemetry.GetPasswordSuccess);
            const cookieString = this.getSessionCookieString(xsrfCookie, sessionCookieName, sessionCookieValue);
            const requestHeaders = { Cookie: cookieString, 'X-XSRFToken': xsrfCookie };
            return { requestHeaders };

DS_INTERNAL.GET_PREFERRED_KERNEL_PERF

Description

Total time taken to get the preferred kernel for notebook.

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.HASHED_NOTEBOOK_OUTPUT_MIME_TYPE_PERF

Description

No description provided

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.HASHED_OUTPUT_MIME_TYPE

Description

No description provided

Properties

  /**
   * 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;
```

Locations Used

src/kernels/jupyter/jupyterCellOutputMimeTypeTracker.ts#L154

            hasJupyter: lowerMimeType.includes('jupyter'),
            hasVnd: lowerMimeType.includes('vnd')
        };
        sendTelemetryEvent(Telemetry.HashedCellOutputMimeType, undefined, props);
    }
}

DS_INTERNAL.HASHED_OUTPUT_MIME_TYPE_PERF

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/jupyter/jupyterCellOutputMimeTypeTracker.ts#L120

        this.pendingChecks.set(id, setTimeout(check, 5000));
    }

    @captureTelemetry(Telemetry.HashedCellOutputMimeTypePerf)
    private checkCell(cell: NotebookCell) {
        this.pendingChecks.delete(cell.document.uri.toString());
        this.getCellOutputMimeTypes(cell).forEach(this.sendTelemetry.bind(this));

DS_INTERNAL.HIDDEN_EXECUTION_TIME

Description

No description provided

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.INTERACTIVE_FILE_TOOLTIPS_PERF

Description

Capture telemetry re: how long returning a tooltip takes

Properties

  // Result is null if user signalled cancellation or if we timed out
  isResultNull: boolean;

Locations Used

src/interactive-window/editor-integration/hoverProvider.ts#L79

        const timeoutHandler = sleep(300).then(() => undefined);
        this.stopWatch.reset();
        const result = await Promise.race([timeoutHandler, this.getVariableHover(document, position, token)]);
        sendTelemetryEvent(Telemetry.InteractiveFileTooltipsPerf, this.stopWatch.elapsedTime, {
            isResultNull: !!result
        });
        return result;

Event can be removed. Not referenced anywhere

DS_INTERNAL.IPYWIDGET_DISCOVERY_ERRORED

Description

Something went wrong in looking for a widget.

Properties

No properties for event

Locations Used

src/kernels/ipywidgets-message-coordination/ipyWidgetScriptSource.ts#L220

            widgetSource = await this.scriptProvider.getWidgetScriptSource(moduleName, moduleVersion);
        } catch (ex) {
            traceError('Failed to get widget source due to an error', ex);
            sendTelemetryEvent(Telemetry.HashedIPyWidgetScriptDiscoveryError);
        } finally {
            traceInfo(
                `${ConsoleForegroundColors.Green}Script for ${moduleName}, is ${widgetSource.scriptUri} from ${widgetSource.source}`

DS_INTERNAL.IPYWIDGET_LOAD_DISABLED

Description

Telemetry event sent when an loading of 3rd party ipywidget JS scripts from 3rd party source has been disabled.

Properties

No properties for event

Locations Used

No properties for event

Locations Used

src/kernels/jupyter/launcher/liveshare/hostJupyterServer.ts#L194

            this.throwIfDisposedOrCancelled(cancelToken);
            const baseUrl = this.connection?.baseUrl || '';
            this.logRemoteOutput(DataScience.createdNewNotebook().format(baseUrl));
            sendKernelTelemetryEvent(resource, Telemetry.JupyterCreatingNotebook, stopWatch.elapsedTime);
            return notebook;
        } catch (ex) {
            sendKernelTelemetryEvent(

src/kernels/jupyter/launcher/liveshare/hostJupyterServer.ts#L199

        } catch (ex) {
            sendKernelTelemetryEvent(
                resource,
                Telemetry.JupyterCreatingNotebook,
                stopWatch.elapsedTime,
                undefined,
                // eslint-disable-next-line @typescript-eslint/no-explicit-any

Telemetry event sent if there's an error installing a jupyter required dependency

@type { product: string } @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.JUPYTER_INTALLED_BUT_NO_KERNELSPEC_MODULE

Description

Telemetry event sent when jupyter has been found in interpreter but we cannot find kernelspec.

@type {(never | undefined)} @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used

src/kernels/jupyter/interpreter/jupyterInterpreterDependencyService.ts#L329

            return JupyterInterpreterDependencyResponse.ok;
        }
        // Indicate no kernel spec module.
        sendTelemetryEvent(Telemetry.JupyterInstalledButNotKernelSpecModule);
        if (Cancellation.isCanceled(token)) {
            return JupyterInterpreterDependencyResponse.cancel;
        }

DS_INTERNAL.JUPYTER_REGISTER_INTERPRETER_AS_KERNEL

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/jupyter/jupyterKernelService.ts#L149

     */
    // eslint-disable-next-line
    // eslint-disable-next-line complexity
    @captureTelemetry(Telemetry.RegisterInterpreterAsKernel, undefined, true)
    @traceDecorators.error('Failed to register an interpreter as a kernel')
    // eslint-disable-next-line
    private async registerKernel(

DS_INTERNAL.JUPYTER_START_TIMEOUT

Description

No description provided

Properties

  /**
   * Total time spent in attempting to start and connect to jupyter before giving up.
   *
   * @type {number}
   */
  timeout: number;

Locations Used

Event can be removed. Not referenced anywhere

Telemetry event sent to every time a kernel enumeration is done

@type {...} @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.KERNEL_FINDER_PERF

Description

Total time taken to find a kernel on disc or on a remote machine.

Properties

No properties for event

Locations Used

src/kernels/raw/finder/localKernelFinder.ts#L55

        @inject(IFileSystem) private readonly fs: IFileSystem
    ) {}
    @traceDecorators.verbose('Find kernel spec', TraceOptions.BeforeCall | TraceOptions.Arguments)
    @captureTelemetry(Telemetry.KernelFinderPerf)
    public async findKernel(
        resource: Resource,
        notebookMetadata?: nbformat.INotebookMetadata,

src/kernels/raw/finder/remoteKernelFinder.ts#L60

        );
    }
    @traceDecorators.verbose('Find remote kernel spec')
    @captureTelemetry(Telemetry.KernelFinderPerf)
    @captureTelemetry(Telemetry.KernelListingPerf, { kind: 'remote' })
    public async findKernel(
        resource: Resource,

DS_INTERNAL.KERNEL_LAUNCHER_PERF

Description

Total time taken to Launch a raw kernel.

Properties

No properties for event

Locations Used

src/kernels/raw/launcher/kernelLauncher.ts#L113

            // Should be available now, wait with a timeout
            return await this.launchProcess(kernelConnectionMetadata, resource, workingDirectory, timeout, cancelToken);
        })();
        sendKernelTelemetryWhenDone(resource, Telemetry.KernelLauncherPerf, promise);
        return promise;
    }

DS_INTERNAL.KERNEL_LISTING_PERF

Description

No description provided

Properties

  /**
   * Whether this is the first time in the session.
   * (fetching kernels first time in the session is slower, later its cached).
   * This is a generic property supported for all telemetry (sent by decorators).
   */
  firstTime?: boolean;

  /**
   * Whether this telemetry is for listing of all kernels or just python or just non-python.
   * (fetching kernels first time in the session is slower, later its cached).
   */
  kind: 'remote' | 'local' | 'localKernelSpec' | 'localPython';

Locations Used

src/kernels/raw/finder/localKnownPathKernelSpecFinder.ts#L45

    /**
     * @param {boolean} includePythonKernels Include/exclude Python kernels in the result.
     */
    @captureTelemetry(Telemetry.KernelListingPerf, { kind: 'localKernelSpec' })
    public async listKernelSpecs(
        includePythonKernels: boolean,
        cancelToken?: CancellationToken

src/kernels/raw/finder/localPythonAndRelatedNonPythonKernelSpecFinder.ts#L74

    ) {
        super(fs, workspaceService, extensionChecker, globalState);
    }
    @captureTelemetry(Telemetry.KernelListingPerf, { kind: 'localPython' })
    public async listKernelSpecs(resource: Resource, ignoreCache?: boolean, cancelToken?: CancellationToken) {
        // Get an id for the workspace folder, if we don't have one, use the fsPath of the resource
        const workspaceFolderId =

src/kernels/raw/finder/localKernelFinder.ts#L191

        return preferredKernel;
    }

    @captureTelemetry(Telemetry.KernelListingPerf, { kind: 'local' })
    private async listKernelsWithoutCache(
        resource: Resource,
        cancelToken?: CancellationToken

src/kernels/raw/finder/remoteKernelFinder.ts#L61

    }
    @traceDecorators.verbose('Find remote kernel spec')
    @captureTelemetry(Telemetry.KernelFinderPerf)
    @captureTelemetry(Telemetry.KernelListingPerf, { kind: 'remote' })
    public async findKernel(
        resource: Resource,
        connInfo: INotebookProviderConnection | undefined,

DS_INTERNAL.KERNEL_NOT_INSTALLED

Description

No description provided

Properties

```
  action: 'displayed';
```
// Message displayed. /** * Language found in the notebook if a known language. Otherwise 'unknown' */ language: string;

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.KERNEL_PROVIDER_PERF

Description

Total time taken to list kernels for VS Code.

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.KERNEL_REGISTER_FAILED

Description

Telemetry event sent to indicate registering a kernel with jupyter failed.

@type {(undefined | never)} @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.KERNEL_SPEC_NOT_FOUND

Description

Telemetry event sent to indicate 'jupyter kernelspec' is not possible.

@type {(undefined | never)} @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used

src/kernels/jupyter/interpreter/jupyterInterpreterDependencyService.ts#L305

            .then(() => true)
            .catch((e) => {
                traceError(`Kernel spec not found: `, e);
                sendTelemetryEvent(Telemetry.KernelSpecNotFound);
                return false;
            });
    }

DS_INTERNAL.LOCAL_KERNEL_SPEC_COUNT

Description

No description provided

Properties

  /**
   * Number of kernel specs.
   */
  count: number;

Locations Used

Event can be removed. Not referenced anywhere

No description provided

Properties

count: number

Locations Used

src/notebooks/notebookUsageTracker.ts#L45

    public dispose() {
        // Send a bunch of telemetry
        if (this.openedNotebookCount) {
            sendTelemetryEvent(Telemetry.NotebookOpenCount, undefined, { count: this.openedNotebookCount });
        }
        if (this.executedNotebooksIndexedByUri.size) {
            sendTelemetryEvent(Telemetry.NotebookRunCount, undefined, {

DS_INTERNAL.NATIVE.NOTEBOOK_OPEN_TIME

Description

No description provided

Properties

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.NATIVE.NOTEBOOK_RUN_COUNT

Description

No description provided

Properties

count: number

Locations Used

src/notebooks/notebookUsageTracker.ts#L48

            sendTelemetryEvent(Telemetry.NotebookOpenCount, undefined, { count: this.openedNotebookCount });
        }
        if (this.executedNotebooksIndexedByUri.size) {
            sendTelemetryEvent(Telemetry.NotebookRunCount, undefined, {
                count: this.executedNotebooksIndexedByUri.size
            });
        }

        }

        // Prune list if too big
        sendTelemetryEvent(Telemetry.NumberOfSavedRemoteKernelIds, undefined, { count: list.length });
        while (list.length > MaximumKernelIdListSize) {
            list.shift();
        }

DS_INTERNAL.PERCEIVED_JUPYTER_STARTUP_NOTEBOOK

Description

Time take for jupyter server to start and be ready to run first user cell.

Properties

No properties for event

Locations Used

src/kernels/kernel.ts#L349

        // Setup telemetry
        if (!this.perceivedJupyterStartupTelemetryCaptured) {
            this.perceivedJupyterStartupTelemetryCaptured = true;
            sendTelemetryEvent(Telemetry.PerceivedJupyterStartupNotebook, stopWatch.elapsedTime);
            executionPromise.finally(() =>
                sendTelemetryEvent(Telemetry.StartExecuteNotebookCellPerceivedCold, stopWatch.elapsedTime)
            );

src/kernels/kernel.ts#L438


            sendKernelTelemetryEvent(
                this.resourceUri,
                Telemetry.PerceivedJupyterStartupNotebook,
                stopWatch.elapsedTime
            );
            this.notebook = notebook;

DS_INTERNAL.PREFERRED_KERNEL

Description

Telemetry sent when we have attempted to find the preferred kernel.

Properties

No properties for event

Locations Used

src/kernels/raw/finder/localKernelFinder.ts#L92


            // Find the preferred kernel index from the list.
            const preferred = findPreferredKernel(kernels, resource, notebookMetadata, preferredInterpreter, undefined);
            sendTelemetryEvent(Telemetry.PreferredKernel, undefined, {
                result: preferred ? 'found' : 'notfound',
                resourceType,
                language: telemetrySafeLanguage,

src/kernels/raw/finder/localKernelFinder.ts#L104

            }
        } catch (ex) {
            sendTelemetryEvent(
                Telemetry.PreferredKernel,
                undefined,
                {
                    result: 'failed',

src/kernels/raw/finder/remoteKernelFinder.ts#L85

                undefined,
                this.preferredRemoteKernelIdProvider
            );
            sendTelemetryEvent(Telemetry.PreferredKernel, undefined, {
                result: preferred ? 'found' : 'notfound',
                resourceType,
                language: telemetrySafeLanguage

src/kernels/raw/finder/remoteKernelFinder.ts#L93

            return preferred;
        } catch (ex) {
            sendTelemetryEvent(
                Telemetry.PreferredKernel,
                undefined,
                { result: 'failed', resourceType, language: telemetrySafeLanguage },
                // eslint-disable-next-line @typescript-eslint/no-explicit-any

DS_INTERNAL.PYTHON_EXTENSION_NOT_INSTALLED

Description

No description provided

Properties

  action:
      | 'displayed' // Message displayed.
      | 'dismissed' // user dismissed the message.
      | 'download';

Locations Used

src/platform/api/pythonApi.ts#L169

        // Ask user if they want to install and then wait for them to actually install it.
        const yes = localize.Common.bannerLabelYes();
        const no = localize.Common.bannerLabelNo();
        sendTelemetryEvent(Telemetry.PythonExtensionNotInstalled, undefined, { action: 'displayed' });
        const answer = await this.appShell.showInformationMessage(
            localize.DataScience.pythonExtensionRequired(),
            { modal: true },

src/platform/api/pythonApi.ts#L177

            no
        );
        if (answer === yes) {
            sendTelemetryEvent(Telemetry.PythonExtensionNotInstalled, undefined, { action: 'download' });
            await this.installPythonExtension();
        } else {
            sendTelemetryEvent(Telemetry.PythonExtensionNotInstalled, undefined, { action: 'dismissed' });

src/platform/api/pythonApi.ts#L180

            sendTelemetryEvent(Telemetry.PythonExtensionNotInstalled, undefined, { action: 'download' });
            await this.installPythonExtension();
        } else {
            sendTelemetryEvent(Telemetry.PythonExtensionNotInstalled, undefined, { action: 'dismissed' });
        }
    }
    private async installPythonExtension() {

src/notebooks/controllers/noPythonKernelsNotebookController.ts#L63

        }
    }
    private async handleExecutionWithoutPythonExtension() {
        sendTelemetryEvent(Telemetry.PythonExtensionNotInstalled, undefined, { action: 'displayed' });
        const selection = await this.appShell.showInformationMessage(
            DataScience.pythonExtensionRequiredToRunNotebook(),
            { modal: true },

src/notebooks/controllers/noPythonKernelsNotebookController.ts#L70

            Common.install()
        );
        if (selection === Common.install()) {
            sendTelemetryEvent(Telemetry.PythonExtensionNotInstalled, undefined, { action: 'download' });
            this.commandManager.executeCommand('extension.open', PythonExtension).then(noop, noop);
        } else {
            sendTelemetryEvent(Telemetry.PythonExtensionNotInstalled, undefined, { action: 'dismissed' });

src/notebooks/controllers/noPythonKernelsNotebookController.ts#L73

            sendTelemetryEvent(Telemetry.PythonExtensionNotInstalled, undefined, { action: 'download' });
            this.commandManager.executeCommand('extension.open', PythonExtension).then(noop, noop);
        } else {
            sendTelemetryEvent(Telemetry.PythonExtensionNotInstalled, undefined, { action: 'dismissed' });
        }
    }
    private async handleExecutionWithoutPython() {

DS_INTERNAL.PYTHON_KERNEL_EXECUTABLE_MATCHES

Description

Telemetry sent for local Python Kernels. Tracking whether we have managed to launch the kernel that matches the interpreter. If match=false, then this means we have failed to launch the right kernel.

Properties

No properties for event

Locations Used

src/kernels/helpers.ts#L1697

            kernelConnection.interpreter.path.toLowerCase(),
            sysExecutable.toLowerCase()
        );
        sendTelemetryEvent(Telemetry.PythonKerneExecutableMatches, undefined, {
            match: match ? 'true' : 'false',
            kernelConnectionType: kernelConnection.kind
        });

src/kernels/helpers.ts#L1721

                });
                if (execOutput.stdout.trim().length > 0) {
                    const match = areInterpreterPathsSame(execOutput.stdout.trim().toLowerCase(), sysExecutable);
                    sendTelemetryEvent(Telemetry.PythonKerneExecutableMatches, undefined, {
                        match: match ? 'true' : 'false',
                        kernelConnectionType: kernelConnection.kind
                    });

DS_INTERNAL.PYTHON_MODULE_INSTALL

Description

No description provided

Properties

```
  moduleName: string;
```

  /**
   * Whether the module was already (once before) installed into the python environment or
   * whether this already exists (detected via `pip list`)
   */
  isModulePresent?: 'true' | undefined;

  action:
      | 'cancelled' // User cancelled the installation or closed the notebook or the like.
      | 'displayed' // Install prompt may have been displayed.
      | 'prompted' // Install prompt was displayed.
      | 'installed' // Installation disabled (this is what python extension returns).
      | 'ignored' // Installation disabled (this is what python extension returns).
      | 'disabled' // Installation disabled (this is what python extension returns).
      | 'failed' // Installation disabled (this is what python extension returns).
      | 'install' // User chose install from prompt.
      | 'donotinstall' // User chose not to install from prompt.
      | 'differentKernel' // User chose to select a different kernel.
      | 'error' // Some other error.
      | 'installedInJupyter' // The package was successfully installed in Jupyter whilst failed to install in Python ext.
      | 'failedToInstallInJupyter' // Failed to install the package in Jupyter as well as Python ext.
      | 'dismissed';

// User chose to dismiss the prompt. resourceType?: 'notebook' | 'interactive';

  /**
   * Hash of the resource (notebook.uri or pythonfile.uri associated with this).
   * If we run the same notebook tomorrow, the hash will be the same.
   */
  resourceHash?: string;

```
  pythonEnvType?: EnvironmentType;
```

Locations Used

src/kernels/installer/productInstaller.ts#L299

            action = 'failed';
            throw ex;
        } finally {
            sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
                action,
                moduleName: ProductNames.get(product)!
            });

src/kernels/jupyter/interpreter/jupyterInterpreterDependencyService.ts#L152

                pipInstalledInNonCondaEnv === false ? [Product.pip].concat(missingProducts) : missingProducts,
                interpreter.displayName
            );
            sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
                action: 'displayed',
                moduleName: ProductNames.get(Product.jupyter)!,
                pythonEnvType: interpreter.envType

src/platform/datascience/data-viewing/dataViewerDependencyService.ts#L71

        interpreter: PythonEnvironment,
        tokenSource: CancellationTokenSource
    ): Promise<void> {
        sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
            action: 'displayed',
            moduleName: ProductNames.get(Product.pandas)!,
            pythonEnvType: interpreter?.envType

src/kernels/kernelDependencyService.ts#L212

        const productNameForTelemetry = products.map((product) => ProductNames.get(product)!).join(', ');
        const resourceType = resource ? getResourceType(resource) : undefined;
        const resourceHash = resource ? getTelemetrySafeHashedString(resource.toString()) : undefined;
        sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
            action: 'displayed',
            moduleName: productNameForTelemetry,
            resourceType,

src/kernels/kernelDependencyService.ts#L230

        const options = resource ? [Common.install(), selectKernel] : [Common.install()];
        try {
            if (!this.isCodeSpace) {
                sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
                    action: 'prompted',
                    moduleName: productNameForTelemetry,
                    resourceType,

src/kernels/kernelDependencyService.ts#L246

                      promptCancellationPromise
                  ]);
            if (cancelTokenSource.token.isCancellationRequested) {
                sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
                    action: 'dismissed',
                    moduleName: productNameForTelemetry,
                    resourceType,

src/kernels/kernelDependencyService.ts#L256

                return KernelInterpreterDependencyResponse.cancel;
            }
            if (selection === selectKernel) {
                sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
                    action: 'differentKernel',
                    moduleName: productNameForTelemetry,
                    resourceType,

src/kernels/kernelDependencyService.ts#L265

                });
                return KernelInterpreterDependencyResponse.selectDifferentKernel;
            } else if (selection === Common.install()) {
                sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
                    action: 'install',
                    moduleName: productNameForTelemetry,
                    resourceType,

src/kernels/kernelDependencyService.ts#L289

                    cancellationPromise
                ]);
                if (response === InstallerResponse.Installed) {
                    sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
                        action: 'installed',
                        moduleName: productNameForTelemetry,
                        resourceType,

src/kernels/kernelDependencyService.ts#L298

                    });
                    return KernelInterpreterDependencyResponse.ok;
                } else if (response === InstallerResponse.Ignore) {
                    sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
                        action: 'failed',
                        moduleName: productNameForTelemetry,
                        resourceType,

src/kernels/kernelDependencyService.ts#L309

                }
            }

            sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
                action: 'dismissed',
                moduleName: productNameForTelemetry,
                resourceType,

src/kernels/kernelDependencyService.ts#L319

            return KernelInterpreterDependencyResponse.cancel;
        } catch (ex) {
            traceError(`Failed to install ${productNameForTelemetry}`, ex);
            sendTelemetryEvent(Telemetry.PythonModuleInstall, undefined, {
                action: 'error',
                moduleName: productNameForTelemetry,
                resourceType,

DS_INTERNAL.PYTHON_NOT_INSTALLED

Description

No description provided

Properties

  action:
      | 'displayed' // Message displayed.
      | 'dismissed' // user dismissed the message.
      | 'download';

Locations Used

src/notebooks/controllers/noPythonKernelsNotebookController.ts#L77

        }
    }
    private async handleExecutionWithoutPython() {
        sendTelemetryEvent(Telemetry.PythonNotInstalled, undefined, { action: 'displayed' });
        const selection = await this.appShell.showErrorMessage(
            DataScience.pythonNotInstalledNonMarkdown(),
            { modal: true },

src/notebooks/controllers/noPythonKernelsNotebookController.ts#L84

            Common.install()
        );
        if (selection === Common.install()) {
            sendTelemetryEvent(Telemetry.PythonNotInstalled, undefined, { action: 'download' });
            this.appShell.openUrl('https://www.python.org/downloads');
        } else {
            sendTelemetryEvent(Telemetry.PythonNotInstalled, undefined, { action: 'dismissed' });

src/notebooks/controllers/noPythonKernelsNotebookController.ts#L87

            sendTelemetryEvent(Telemetry.PythonNotInstalled, undefined, { action: 'download' });
            this.appShell.openUrl('https://www.python.org/downloads');
        } else {
            sendTelemetryEvent(Telemetry.PythonNotInstalled, undefined, { action: 'dismissed' });
        }
    }
}

DS_INTERNAL.RAWKERNEL_CREATING_NOTEBOOK

Description

Telemetry send when we create a notebook for a raw kernel or jupyter

Properties

No properties for event

Locations Used

src/kernels/raw/session/hostRawNotebookProvider.ts#L93

        return this.rawNotebookSupportedService.isSupported;
    }

    @captureTelemetry(Telemetry.RawKernelCreatingNotebook, undefined, true)
    public async createNotebook(
        document: vscode.NotebookDocument,
        resource: Resource,

DS_INTERNAL.RAWKERNEL_INFO_RESPONSE

Description

After starting a kernel we send a request to get the kernel info. This tracks the total time taken to get the response back (or wether we timedout). If we timeout and later we find successful comms for this session, then timeout is too low or we need more attempts.

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawJupyterSession.ts#L349

        } else {
            traceWarning(`Didn't get response for requestKernelInfo after ${stopWatch.elapsedTime}ms.`);
        }
        sendTelemetryEvent(Telemetry.RawKernelInfoResonse, stopWatch.elapsedTime, {
            attempts,
            timedout: !gotIoPubMessage.completed
        });

DS_INTERNAL.RAWKERNEL_PROCESS_LAUNCH

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/raw/launcher/kernelProcess.ts#L119

        }
    }

    @captureTelemetry(Telemetry.RawKernelProcessLaunch, undefined, true)
    public async launch(workingDirectory: string, timeout: number, cancelToken: CancellationToken): Promise<void> {
        if (this.launchedOnce) {
            throw new Error('Kernel has already been launched.');

DS_INTERNAL.RAWKERNEL_SESSION_CONNECT

Description

Raw kernel timing events

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawJupyterSession.ts#L146

                throw error;
            }
        } finally {
            sendKernelTelemetryEvent(this.resource, Telemetry.RawKernelSessionConnect, stopWatch.elapsedTime);
        }

        this.connected = true;

DS_INTERNAL.RAWKERNEL_SESSION_DISPOSED

Description

This event is sent when a RawSession's dispose method is called.

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawSession.ts#L95

    public async dispose() {
        // We want to know who called dispose on us
        const stacktrace = new Error().stack;
        sendTelemetryEvent(Telemetry.RawKernelSessionDisposed, undefined, { stacktrace });

        // Now actually dispose ourselves
        this.isDisposing = true;

DS_INTERNAL.RAWKERNEL_SESSION_KERNEL_PROCESS_EXITED

Description

This event is sent when the underlying kernelProcess for a RawJupyterSession exits.

Properties

No properties for event

Locations Used

src/kernels/raw/launcher/kernelLauncher.ts#L213


        const disposable = kernelProcess.exited(
            ({ exitCode, reason }) => {
                sendTelemetryEvent(Telemetry.RawKernelSessionKernelProcessExited, undefined, {
                    exitCode,
                    exitReason: getTelemetrySafeErrorMessageFromPythonTraceback(reason)
                });

src/kernels/raw/session/rawSession.ts#L255

        traceError(`Disposing session as kernel process died ExitCode: ${e.exitCode}, Reason: ${e.reason}`);
        // Send telemetry so we know why the kernel process exited,
        // as this affects our kernel startup success
        sendTelemetryEvent(Telemetry.RawKernelSessionKernelProcessExited, undefined, {
            exitCode: e.exitCode,
            exitReason: getTelemetrySafeErrorMessageFromPythonTraceback(e.reason)
        });

src/kernels/raw/session/rawJupyterSession.ts#L190

            if (session !== this.session) {
                return;
            }
            sendTelemetryEvent(Telemetry.RawKernelSessionKernelProcessExited, undefined, {
                exitCode,
                exitReason: getTelemetrySafeErrorMessageFromPythonTraceback(reason)
            });

DS_INTERNAL.RAWKERNEL_SESSION_NO_IPYKERNEL

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/helpers.ts#L1951

    const isLocal = isLocalConnection(controller?.connection);
    const rawLocalKernel = serviceContainer.get<IRawNotebookProvider>(IRawNotebookProvider).isSupported && isLocal;
    if (rawLocalKernel && context === 'start') {
        sendKernelTelemetryEvent(resource, Telemetry.RawKernelSessionStartNoIpykernel, {
            reason: handleResult
        });
    }

DS_INTERNAL.RAWKERNEL_SESSION_SHUTDOWN

Description

This event is sent when a RawJupyterSession's shutdownSession method is called.

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawJupyterSession.ts#L164

        // We want to know why we got shut down
        const stacktrace = new Error().stack;
        return super.shutdownSession(session, statusHandler, isRequestToShutdownRestartSession).then(() => {
            sendTelemetryEvent(Telemetry.RawKernelSessionShutdown, undefined, {
                isRequestToShutdownRestartSession,
                stacktrace
            });

DS_INTERNAL.RAWKERNEL_SESSION_START

Description

Raw kernel single events

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawJupyterSession.ts#L87

            Cancellation.throwIfCanceled(options.token);
            // Only connect our session if we didn't cancel or timeout
            sendKernelTelemetryEvent(this.resource, Telemetry.RawKernelSessionStartSuccess);
            sendKernelTelemetryEvent(this.resource, Telemetry.RawKernelSessionStart, stopWatch.elapsedTime);
            traceInfo('Raw session started and connected');
            this.setSession(newSession);

src/kernels/raw/session/rawJupyterSession.ts#L104

            if (error instanceof CancellationError) {
                sendKernelTelemetryEvent(
                    this.resource,
                    Telemetry.RawKernelSessionStart,
                    stopWatch.elapsedTime,
                    undefined,
                    error

src/kernels/raw/session/rawJupyterSession.ts#L115

            } else if (error instanceof TimedOutError) {
                sendKernelTelemetryEvent(
                    this.resource,
                    Telemetry.RawKernelSessionStart,
                    stopWatch.elapsedTime,
                    undefined,
                    error

src/kernels/raw/session/rawJupyterSession.ts#L127

                // Send our telemetry event with the error included
                sendKernelTelemetryEvent(
                    this.resource,
                    Telemetry.RawKernelSessionStart,
                    stopWatch.elapsedTime,
                    undefined,
                    // eslint-disable-next-line @typescript-eslint/no-explicit-any

DS_INTERNAL.RAWKERNEL_SESSION_START_EXCEPTION

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawJupyterSession.ts#L135

                );
                sendKernelTelemetryEvent(
                    this.resource,
                    Telemetry.RawKernelSessionStartException,
                    undefined,
                    undefined,
                    // eslint-disable-next-line @typescript-eslint/no-explicit-any

DS_INTERNAL.RAWKERNEL_SESSION_START_SUCCESS

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawJupyterSession.ts#L86

            newSession = await this.startRawSession(options);
            Cancellation.throwIfCanceled(options.token);
            // Only connect our session if we didn't cancel or timeout
            sendKernelTelemetryEvent(this.resource, Telemetry.RawKernelSessionStartSuccess);
            sendKernelTelemetryEvent(this.resource, Telemetry.RawKernelSessionStart, stopWatch.elapsedTime);
            traceInfo('Raw session started and connected');
            this.setSession(newSession);

DS_INTERNAL.RAWKERNEL_SESSION_START_TIMEOUT

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawJupyterSession.ts#L120

                    undefined,
                    error
                );
                sendKernelTelemetryEvent(this.resource, Telemetry.RawKernelSessionStartTimeout);
                traceError('Raw session failed to start in given timeout');
                throw error;
            } else {

DS_INTERNAL.RAWKERNEL_SESSION_START_USER_CANCEL

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawJupyterSession.ts#L109

                    undefined,
                    error
                );
                sendKernelTelemetryEvent(this.resource, Telemetry.RawKernelSessionStartUserCancel);
                traceInfo('Starting of raw session cancelled by user');
                throw error;
            } else if (error instanceof TimedOutError) {

DS_INTERNAL.RAWKERNEL_START_RAW_SESSION

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawJupyterSession.ts#L237

        return this.startRawSession({ token: cancelToken, ui: new DisplayOptions(disableUI) });
    }

    @captureTelemetry(Telemetry.RawKernelStartRawSession, undefined, true)
    private async startRawSession(options: { token: CancellationToken; ui: IDisplayOptions }): Promise<RawSession> {
        if (
            this.kernelConnectionMetadata.kind !== 'startUsingLocalKernelSpec' &&

DS_INTERNAL.REGISTER_AND_USE_INTERPRETER_AS_KERNEL

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/jupyter/jupyterKernelService.ts#L225

            );
        }

        sendTelemetryEvent(Telemetry.RegisterAndUseInterpreterAsKernel);
        return kernelSpecFilePath;
    }
    private async updateKernelEnvironment(

DS_INTERNAL.REMOTE_KERNEL_SPEC_COUNT

Description

No description provided

Properties

  /**
   * Number of kernel specs.
   */
  count: number;

Locations Used

Event can be removed. Not referenced anywhere

No description provided

Properties

  /**
   * The result of the selection.
   * notSelected - No interpreter was selected.
   * selected - An interpreter was selected (and configured to have jupyter and notebook).
   * installationCancelled - Installation of jupyter and/or notebook was cancelled for an interpreter.
   *
   * @type {('notSelected' | 'selected' | 'installationCancelled')}
   */
  result?: 'notSelected' | 'selected' | 'installationCancelled';

Locations Used

src/kernels/jupyter/interpreter/jupyterInterpreterService.ts#L86

    public async selectInterpreter(): Promise<PythonEnvironment | undefined> {
        const interpreter = await this.jupyterInterpreterSelector.selectInterpreter();
        if (!interpreter) {
            sendTelemetryEvent(Telemetry.SelectJupyterInterpreter, undefined, { result: 'notSelected' });
            return;
        }

src/kernels/jupyter/interpreter/jupyterInterpreterService.ts#L97

                return interpreter;
            }
            case JupyterInterpreterDependencyResponse.cancel:
                sendTelemetryEvent(Telemetry.SelectJupyterInterpreter, undefined, { result: 'installationCancelled' });
                return;
            default:
                return this.selectInterpreter();

src/kernels/jupyter/interpreter/jupyterInterpreterService.ts#L162

        this._selectedInterpreter = interpreter;
        this._onDidChangeInterpreter.fire(interpreter);
        this.interpreterSelectionState.updateSelectedPythonPath(interpreter.path);
        sendTelemetryEvent(Telemetry.SelectJupyterInterpreter, undefined, { result: 'selected' });
    }

    // For a given python path check if it can run jupyter for us

DS_INTERNAL.SELECT_JUPYTER_INTERPRETER_MESSAGE_DISPLAYED

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/jupyter/interpreter/jupyterInterpreterSubCommandExecutionService.ts#L86

            if (!interpreter) {
                // Unlikely scenario, user hasn't selected python, python extension will fall over.
                // Get user to select something.
                sendTelemetryEvent(Telemetry.SelectJupyterInterpreterMessageDisplayed);
                return DataScience.selectJupyterInterpreter();
            }
        }

DS_INTERNAL.SETTINGS

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/datascience/datascience.ts#L126

                    resultSettings[k] = currentValue;
                }
            }
            sendTelemetryEvent(Telemetry.DataScienceSettings, 0, resultSettings);
        }
    }
}

DS_INTERNAL.SHIFTENTER_BANNER_SHOWN

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/datascience/shiftEnterBanner.ts#L68

            return;
        }

        sendTelemetryEvent(Telemetry.ShiftEnterBannerShown);
        const response = await this.appShell.showInformationMessage(this.bannerMessage, ...this.bannerLabels);
        switch (response) {
            case this.bannerLabels[InteractiveShiftEnterLabelIndex.Yes]: {

src/test/datascience/shiftEnterBanner.unit.test.ts#L68

        config.verifyAll();

        expect(Reporter.eventNames).to.deep.equal([
            Telemetry.ShiftEnterBannerShown,
            Telemetry.EnableInteractiveShiftEnter
        ]);
    });

src/test/datascience/shiftEnterBanner.unit.test.ts#L99

        config.verifyAll();

        expect(Reporter.eventNames).to.deep.equal([
            Telemetry.ShiftEnterBannerShown,
            Telemetry.DisableInteractiveShiftEnter
        ]);
    });

No properties for event

Locations Used

Event can be removed. Not referenced anywhere

DS_INTERNAL.START_SESSION_FAILED_JUPYTER

Description

Telemetry event sent when starting a session for a local connection failed.

@type {(undefined | never)} @memberof IEventNamePropertyMapping

Properties

No properties for event

Locations Used

src/kernels/common/baseJupyterSession.ts#L40

export class JupyterSessionStartError extends WrappedError {
    constructor(originalException: Error) {
        super(originalException.message, originalException);
        sendTelemetryEvent(Telemetry.StartSessionFailedJupyter, undefined, undefined, originalException, true);
    }
}

DS_INTERNAL.SWITCH_KERNEL

Description

No description provided

Properties

No properties for event

Locations Used

src/notebooks/controllers/vscodeNotebookController.ts#L566

            default:
            // We don't know as its the default kernel on Jupyter server.
        }
        sendKernelTelemetryEvent(document.uri, Telemetry.SwitchKernel);
        // If we have an existing kernel, then we know for a fact the user is changing the kernel.
        // Else VSC is just setting a kernel for a notebook after it has opened.
        if (existingKernel) {

DS_INTERNAL.SWITCH_TO_EXISTING_KERNEL

Description

No description provided

Properties

language: string

Locations Used

src/platform/datascience/common.ts#L171

}

export function sendNotebookOrKernelLanguageTelemetry(
    telemetryEvent: Telemetry.SwitchToExistingKernel | Telemetry.NotebookLanguage,
    language?: string
) {
    language = getTelemetrySafeLanguage(language);

src/notebooks/controllers/vscodeNotebookController.ts#L548

        }
        switch (this.connection.kind) {
            case 'startUsingPythonInterpreter':
                sendNotebookOrKernelLanguageTelemetry(Telemetry.SwitchToExistingKernel, PYTHON_LANGUAGE);
                break;
            case 'connectToLiveKernel':
                sendNotebookOrKernelLanguageTelemetry(

src/notebooks/controllers/vscodeNotebookController.ts#L552

                break;
            case 'connectToLiveKernel':
                sendNotebookOrKernelLanguageTelemetry(
                    Telemetry.SwitchToExistingKernel,
                    this.connection.kernelModel.language
                );
                break;

src/notebooks/controllers/vscodeNotebookController.ts#L559

            case 'startUsingLocalKernelSpec':
            case 'startUsingRemoteKernelSpec':
                sendNotebookOrKernelLanguageTelemetry(
                    Telemetry.SwitchToExistingKernel,
                    this.connection.kernelSpec.language
                );
                break;

    }

    // IJupyterVariables implementation
    @captureTelemetry(Telemetry.VariableExplorerFetchTime, undefined, true)
    public async getVariables(request: IJupyterVariablesRequest, kernel?: IKernel): Promise<IJupyterVariablesResponse> {
        return this.variableHandler.getVariables(request, kernel);
    }

DS_INTERNAL.VARIABLE_EXPLORER_VARIABLE_COUNT

Description

No description provided

Properties

variableCount: number

Locations Used

src/platform/datascience/variablesView/variableView.ts#L187

            const response = await this.variables.getVariables(args, activeNotebook);

            this.postMessage(InteractiveWindowMessages.GetVariablesResponse, response).ignoreErrors();
            sendTelemetryEvent(Telemetry.VariableExplorerVariableCount, undefined, {
                variableCount: response.totalCount
            });
        } else {

DS_INTERNAL.VSCNOTEBOOK_CELL_TRANSLATION_FAILED

Description

No description provided

Properties

```
  isErrorOutput: boolean;
```

Locations Used

src/notebooks/helpers.ts#L736

            // Unless we already know its an unknown output type.
            const outputType: nbformat.OutputType =
                <nbformat.OutputType>customMetadata?.outputType || (isStream ? 'stream' : 'display_data');
            sendTelemetryEvent(Telemetry.VSCNotebookCellTranslationFailed, undefined, {
                isErrorOutput: outputType === 'error'
            });

DS_INTERNAL.WAIT_FOR_IDLE_JUPYTER

Description

No description provided

Properties

No properties for event

Locations Used

src/kernels/jupyter/session/jupyterSession.ts#L78

        super(resource, kernelConnectionMetadata, restartSessionUsed, workingDirectory, interruptTimeout);
    }

    @captureTelemetry(Telemetry.WaitForIdleJupyter, undefined, true)
    public waitForIdle(timeout: number): Promise<void> {
        // Wait for idle on this session
        return this.waitForIdleOnSession(this.session, timeout);

DS_INTERNAL.WEBVIEW_STARTUP

Description

No description provided

Properties

type: string

Locations Used

src/platform/datascience/webviews/webviewHost.ts#L282

    protected webViewRendered() {
        if (this.webviewInit && !this.webviewInit.resolved) {
            // Send telemetry for startup
            sendTelemetryEvent(Telemetry.WebviewStartup, this.startupStopwatch.elapsedTime, { type: this.title });

            // Resolve our started promise. This means the webpanel is ready to go.
            this.webviewInit.resolve();

DS_INTERNAL.WEBVIEW_STYLE_UPDATE

Description

No description provided

Properties

No properties for event

Locations Used

src/platform/datascience/webviews/webviewHost.ts#L300

        this.dispose();
    };

    @captureTelemetry(Telemetry.WebviewStyleUpdate)
    private async handleCssRequest(request: IGetCssRequest): Promise<void> {
        const settings = await this.generateDataScienceExtraSettings();
        const requestIsDark = settings.ignoreVscodeTheme ? false : request?.isDark;

DS_INTERNAL.ZMQ_NATIVE_BINARIES_LOADING

Description

Telemetry event sent when the ZMQ native binaries do work.

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawNotebookSupportedService.ts#L43

        try {
            require('zeromq');
            traceInfo(`ZMQ install verified.`);
            sendTelemetryEvent(Telemetry.ZMQSupported);
            this._isSupported = true;
        } catch (e) {
            traceError(`Exception while attempting zmq :`, e);

DS_INTERNAL.ZMQ_NATIVE_BINARIES_NOT_LOADING

Description

Telemetry event sent when the ZMQ native binaries do not work.

Properties

No properties for event

Locations Used

src/kernels/raw/session/rawNotebookSupportedService.ts#L47

            this._isSupported = true;
        } catch (e) {
            traceError(`Exception while attempting zmq :`, e);
            sendTelemetryEvent(Telemetry.ZMQNotSupported);
            this._isSupported = false;
        }

ENVFILE_VARIABLE_SUBSTITUTION

Description

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

Properties

No properties for event

Locations Used

src/platform/common/variables/environment.ts#L173

    });
    if (!invalid && replacement !== value) {
        value = replacement;
        sendTelemetryEvent(EventName.ENVFILE_VARIABLE_SUBSTITUTION);
    }

    return value.replace(/\\\$/g, '$');

ENVFILE_WORKSPACE

Description

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

Properties

No properties for event

Locations Used

src/telemetry/envFileTelemetry.ts#L46

}

function sendTelemetry(hasCustomEnvPath: boolean = false) {
    sendTelemetryEvent(EventName.ENVFILE_WORKSPACE, undefined, { hasCustomEnvPath });

    envFileTelemetrySent = true;
}

EXTENSION.LOAD

Description

Telemetry event sent with details just after editor loads

Properties

No properties for event

Locations Used

src/telemetry/types.ts#L10

import { IEventNamePropertyMapping } from '../telemetry/index';
import { EventName } from './constants';

export type EditorLoadTelemetry = IEventNamePropertyMapping[EventName.EXTENSION_LOAD];
export const IImportTracker = Symbol('IImportTracker');
export interface IImportTracker {}

src/platform/startupTelemetry.ts#L31

        await activatedPromise;
        durations.totalActivateTime = stopWatch.elapsedTime;
        const props = await getActivationTelemetryProps(serviceContainer);
        sendTelemetryEvent(EventName.EXTENSION_LOAD, durations, props);
    } catch (ex) {
        traceError('sendStartupTelemetry() failed.', ex);
    }

src/platform/startupTelemetry.ts#L52

                traceError('getActivationTelemetryProps() failed.', ex);
            }
        }
        sendTelemetryEvent(EventName.EXTENSION_LOAD, durations, props, ex);
    } catch (exc2) {
        traceError('sendErrorTelemetry() failed.', exc2);
    }

HASHED_PACKAGE_NAME

Description

Telemetry event sent with details when tracking imports

Properties

No properties for event

Locations Used

src/telemetry/importTracker.ts#L205

        // Hash the package name so that we will never accidentally see a
        // user's private package name.
        const hash = getTelemetrySafeHashedString(packageName);
        sendTelemetryEvent(EventName.HASHED_PACKAGE_NAME, undefined, { hashedNamev2: hash });
    }

    private lookForImports(lines: (string | undefined)[]) {

src/test/telemetry/importTracker.unit.test.ts#L44

        public static expectHashes(...hashes: string[]) {
            expect(Reporter.eventNames).to.contain(EventName.HASHED_PACKAGE_PERF);
            if (hashes.length > 0) {
                expect(Reporter.eventNames).to.contain(EventName.HASHED_PACKAGE_NAME);
            }

            Reporter.properties.pop(); // HASHED_PACKAGE_PERF

HASHED_PACKAGE_PERF

Description

No description provided

Properties

No properties for event

Locations Used

src/telemetry/importTracker.ts#L158

        }
    }

    @captureTelemetry(EventName.HASHED_PACKAGE_PERF)
    private checkNotebookDocument(e: NotebookDocument) {
        this.pendingChecks.delete(e.uri.fsPath);
        const lines = this.getNotebookDocumentLines(e);

src/telemetry/importTracker.ts#L165

        this.lookForImports(lines);
    }

    @captureTelemetry(EventName.HASHED_PACKAGE_PERF)
    private checkNotebookCell(e: NotebookCellExecutionStateChangeEvent) {
        if (!isJupyterNotebook(e.cell.notebook)) {
            return;

src/telemetry/importTracker.ts#L189

        this.lookForImports(result);
    }

    @captureTelemetry(EventName.HASHED_PACKAGE_PERF)
    private checkDocument(document: TextDocument) {
        this.pendingChecks.delete(document.fileName);
        const lines = this.getDocumentLines(document);

src/test/telemetry/importTracker.unit.test.ts#L42

        public static measures: {}[] = [];

        public static expectHashes(...hashes: string[]) {
            expect(Reporter.eventNames).to.contain(EventName.HASHED_PACKAGE_PERF);
            if (hashes.length > 0) {
                expect(Reporter.eventNames).to.contain(EventName.HASHED_PACKAGE_NAME);
            }

JUPYTER_EXPERIMENTS_OPT_IN_OUT

Description

Telemetry event sent with details when a user has requested to opt it or out of an experiment group

Properties

No properties for event

Locations Used

src/platform/common/experiments/service.ts#L104

        // so we need to perform these checks and send the corresponding telemetry manually.
        switch (this.getOptInOptOutStatus(experiment)) {
            case 'optOut': {
                sendTelemetryEvent(EventName.JUPYTER_EXPERIMENTS_OPT_IN_OUT, undefined, {
                    expNameOptedOutOf: experiment
                });

src/platform/common/experiments/service.ts#L112

            }
            case 'optIn': {
                await this.experimentationService.isCachedFlightEnabled(experiment);
                sendTelemetryEvent(EventName.JUPYTER_EXPERIMENTS_OPT_IN_OUT, undefined, {
                    expNameOptedInto: experiment
                });

src/test/common/experiments/service.unit.test.ts#L221

            assert.isTrue(result);
            assert.equal(telemetryEvents.length, 1);
            assert.deepEqual(telemetryEvents[0], {
                eventName: EventName.JUPYTER_EXPERIMENTS_OPT_IN_OUT,
                properties: { expNameOptedInto: experiment }
            });
            sinon.assert.calledOnce(isCachedFlightEnabledStub);

src/test/common/experiments/service.unit.test.ts#L241

            assert.isFalse(result);
            assert.equal(telemetryEvents.length, 1);
            assert.deepEqual(telemetryEvents[0], {
                eventName: EventName.JUPYTER_EXPERIMENTS_OPT_IN_OUT,
                properties: { expNameOptedOutOf: experiment }
            });
            sinon.assert.notCalled(isCachedFlightEnabledStub);

src/platform/common/platform/platformService.ts#L21

    public version?: SemVer;
    constructor() {
        if (this.osType === OSType.Unknown) {
            sendTelemetryEvent(EventName.PLATFORM_INFO, undefined, {
                failureType: PlatformErrors.FailedToDetermineOS
            });
        }

src/platform/common/platform/platformService.ts#L45

                try {
                    const ver = coerce(os.release());
                    if (ver) {
                        sendTelemetryEvent(EventName.PLATFORM_INFO, undefined, {
                            osVersion: `${ver.major}.${ver.minor}.${ver.patch}`
                        });
                        return (this.version = ver);

src/platform/common/platform/platformService.ts#L52

                    }
                    throw new Error('Unable to parse version');
                } catch (ex) {
                    sendTelemetryEvent(EventName.PLATFORM_INFO, undefined, {
                        failureType: PlatformErrors.FailedToParseVersion
                    });
                    return parseVersion(os.release());

PYTHON_INTERPRETER_ACTIVATION_ENVIRONMENT_VARIABLES

Description

No description provided

Properties

  /**
   * 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;

Locations Used

src/platform/common/process/pythonExecutionFactory.ts#L164

            options.allowEnvironmentFetchExceptions
        );
        const hasEnvVars = envVars && Object.keys(envVars).length > 0;
        sendTelemetryEvent(EventName.PYTHON_INTERPRETER_ACTIVATION_ENVIRONMENT_VARIABLES, undefined, { hasEnvVars });
        if (!hasEnvVars) {
            return this.create({
                resource: options.resource,

219 KiB Raw Blame History

Telemetry created by Jupyter Extension

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

Description

Properties

Locations Used

219 KiB

Raw Blame History