Add telemetry

src/client/common/telemetry/constants.ts

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+export const COMPLETION = 'COMPLETION';
+export const DEFINITION = 'DEFINITION';
+export const HOVER_DEFINITION = 'HOVER_DEFINITION';
+export const REFERENCE = 'REFERENCE';
+export const SIGNATURE = 'SIGNATURE';
+export const SYMBOL = 'SYMBOL';
+export const FORMAT_SORT_IMPORTS = 'FORMAT.SORT_IMPORTS';
+export const FORMAT = 'FORMAT.FORMAT';
+export const EDITOR_LOAD = 'EDITOR.LOAD';
+export const LINTING = 'LINTING';
+export const GO_TO_OBJECT_DEFINITION = 'GO_TO_OBJECT_DEFINITION';
+export const UPDATE_PYSPARK_LIBRARY = 'UPDATE_PYSPARK_LIBRARY';
+export const REFACTOR_RENAME = 'REFACTOR_RENAME';
+export const REFACTOR_EXTRACT_VAR = 'REFACTOR_EXTRACT_VAR';
+export const REFACTOR_EXTRACT_FUNCTION = 'REFACTOR_EXTRACT_FUNCTION';
+export const REPL = 'REPL';
+export const PYTHON_INTERPRETER = 'PYTHON_INTERPRETER';
+export const WORKSPACE_SYMBOLS_BUILD = 'WORKSPACE_SYMBOLS.BUILD';
+export const WORKSPACE_SYMBOLS_GO_TO = 'WORKSPACE_SYMBOLS.GO_TO';
+export const EXECUTION_CODE = 'EXECUTION_CODE';
+export const EXECUTION_DJANGO = 'EXECUTION_DJANGO';
+export const DEBUGGER = 'DEBUGGER';
+export const UNITTEST_STOP = 'UNITTEST.STOP';
+export const UNITTEST_RUN = 'UNITTEST.RUN';
+export const UNITTEST_DISCOVER = 'UNITTEST.DISCOVER';
+export const UNITTEST_VIEW_OUTPUT = 'UNITTEST.VIEW_OUTPUT';

src/client/common/telemetry/index.ts

@@ -0,0 +1,82 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { StopWatch } from './stopWatch';
+import { getTelemetryReporter } from './telemetry';
+import { TelemetryProperties } from './types';
+
+export function sendTelemetryEvent(eventName: string, durationMs?: number, properties?: TelemetryProperties) {
+    const reporter = getTelemetryReporter();
+    const measures = typeof durationMs === 'number' ? { duration: durationMs } : undefined;
+
+    // tslint:disable-next-line:no-any
+    const customProperties: { [key: string]: string } = {};
+    if (properties) {
+        // tslint:disable-next-line:prefer-type-cast no-any
+        const data = properties as any;
+        Object.getOwnPropertyNames(data).forEach(prop => {
+            // tslint:disable-next-line:prefer-type-cast no-any  no-unsafe-any
+            (customProperties as any)[prop] = typeof data[prop] === 'string' ? data[prop] : data[prop].toString();
+        });
+    }
+    //
+    reporter.sendTelemetryEvent(eventName, properties ? customProperties : undefined, measures);
+}
+
+// tslint:disable-next-line:no-any function-name
+export function captureTelemetry(eventName: string) {
+    // tslint:disable-next-line:no-function-expression no-any
+    return function (target: Object, propertyKey: string, descriptor: TypedPropertyDescriptor<any>) {
+        const originalMethod = descriptor.value;
+        // tslint:disable-next-line:no-function-expression no-any
+        descriptor.value = function (...args: any[]) {
+            const stopWatch = new StopWatch();
+            // tslint:disable-next-line:no-invalid-this no-use-before-declare no-unsafe-any
+            const result = originalMethod.apply(this, args);
+
+            // If method being wrapped returns a promise then wait for it.
+            // tslint:disable-next-line:no-unsafe-any
+            if (result && typeof result.then === 'function' && typeof result.catch === 'function') {
+                // tslint:disable-next-line:prefer-type-cast
+                (result as Promise<void>)
+                    .then(data => {
+                        sendTelemetryEvent(eventName, stopWatch.elapsedTime);
+                        return data;
+                    })
+                    // tslint:disable-next-line:promise-function-async
+                    .catch(ex => {
+                        sendTelemetryEvent(eventName, stopWatch.elapsedTime);
+                        return Promise.reject(ex);
+                    });
+            } else {
+                sendTelemetryEvent(eventName, stopWatch.elapsedTime);
+            }
+
+            return result;
+        };
+
+        return descriptor;
+    };
+}
+
+// tslint:disable-next-line:no-any function-name
+export function sendTelemetryWhenDone(eventName: string, promise: Promise<any> | Thenable<any>,
+    stopWatch?: StopWatch, properties?: TelemetryProperties) {
+    stopWatch = stopWatch ? stopWatch : new StopWatch();
+    if (typeof promise.then === 'function') {
+        // tslint:disable-next-line:prefer-type-cast no-any
+        (promise as Promise<any>)
+            .then(data => {
+                // tslint:disable-next-line:no-non-null-assertion
+                sendTelemetryEvent(eventName, stopWatch!.elapsedTime, properties);
+                return data;
+                // tslint:disable-next-line:promise-function-async
+            }, ex => {
+                // tslint:disable-next-line:no-non-null-assertion
+                sendTelemetryEvent(eventName, stopWatch!.elapsedTime, properties);
+                return Promise.reject(ex);
+            });
+    } else {
+        throw new Error('Method is neither a Promise nor a Theneable');
+    }
+}

src/client/common/telemetry/stopWatch.ts

@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+export class StopWatch {
+    private started: number = Date.now();
+    private stopped?: number;
+    public get elapsedTime() {
+        return (this.stopped ? this.stopped : Date.now()) - this.started;
+    }
+    public stop() {
+        this.stopped = Date.now();
+    }
+}

src/client/common/telemetry/telemetry.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// tslint:disable-next-line:no-reference
+/// <reference path="./vscode-extension-telemetry.d.ts" />
+import { extensions } from 'vscode';
+// tslint:disable-next-line:import-name
+import TelemetryReporter from 'vscode-extension-telemetry';
+
+// tslint:disable-next-line:no-any
+let telemetryReporter: TelemetryReporter;
+export function getTelemetryReporter() {
+    if (telemetryReporter) {
+        return telemetryReporter;
+    }
+    const extensionId = 'donjayamanne.python';
+    // tslint:disable-next-line:no-non-null-assertion
+    const extension = extensions.getExtension(extensionId)!;
+    // tslint:disable-next-line:no-unsafe-any
+    const extensionVersion = extension.packageJSON.version;
+    // tslint:disable-next-line:no-unsafe-any
+    const aiKey = extension.packageJSON.contributes.debuggers[0].aiKey;
+
+    // tslint:disable-next-line:no-unsafe-any
+    return telemetryReporter = new TelemetryReporter(extensionId, extensionVersion, aiKey);
+}

src/client/common/telemetry/types.ts

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+export type EditorLoadTelemetry = {
+    condaVersion: string;
+};
+export type FormatTelemetry = {
+    tool: 'autoppep8' | 'yapf';
+    hasCustomArgs: boolean;
+    formatSelection: boolean;
+};
+export type LintingTelemetry = {
+    tool: 'flake8' | 'mypy' | 'pep8' | 'prospector' | 'pydocstyle' | 'pylama' | 'pylint';
+    hasCustomArgs: boolean;
+    trigger: 'save' | 'auto';
+    executableSpecified: boolean;
+};
+export type PythonInterpreterTelemetry = {
+    trigger: 'ui' | 'shebang' | 'load';
+    failed: boolean;
+    version: string;
+    pipVersion: string;
+};
+export type CodeExecutionTelemetry = {
+    scope: 'file' | 'selection';
+};
+export type DebuggerTelemetry = {
+    trigger: 'launch' | 'attach'
+    console?: 'none' | 'integratedTerminal' | 'externalTerminal';
+    debugOptions?: string;
+    pyspark?: boolean;
+    hasEnvVars?: boolean;
+};
+export type TestRunTelemetry = {
+    tool: 'nosetest' | 'pytest' | 'unittest'
+    scope: 'currentFile' | 'all' | 'file' | 'class' | 'function' | 'failed';
+    debugging: boolean;
+    trigger: 'ui' | 'codelens' | 'commandpalette' | 'auto';
+    failed: boolean;
+};
+export type TestDiscoverytTelemetry = {
+    tool: 'nosetest' | 'pytest' | 'unittest'
+    trigger: 'ui' | 'commandpalette';
+    failed: boolean;
+};
+export type TelemetryProperties = FormatTelemetry | LintingTelemetry | EditorLoadTelemetry | PythonInterpreterTelemetry | CodeExecutionTelemetry | TestRunTelemetry | TestDiscoverytTelemetry;

src/client/typings/vscode-extension-telemetry/vscode-extension-telemetry.d.ts → src/client/common/telemetry/vscode-extension-telemetry.d.ts

@@ -1,36 +1,26 @@
-declare module "vscode-extension-telemetry" {
+declare module 'vscode-extension-telemetry' {
     export default class TelemetryReporter {
-        private extensionId;
-        private extensionVersion;
-        private appInsightsClient;
-        private commonProperties;
-        private static SQM_KEY;
-        private static REGISTRY_USERID_VALUE;
-        private static REGISTRY_MACHINEID_VALUE;
-
         /**
          * Constructs a new telemetry reporter
          * @param {string} extensionId All events will be prefixed with this event name
          * @param {string} extensionVersion Extension version to be reported with each event
          * @param {string} key The application insights key
          */
+        // tslint:disable-next-line:no-empty
         constructor(extensionId: string, extensionVersion: string, key: string);
-        private setupAIClient(client);
-        private loadVSCodeCommonProperties(machineId, sessionId, version);
-        private loadCommonProperties();
-        private addCommonProperties(properties);
-        private getWinRegKeyData(key, name, hive, callback);
 
         /**
          * Sends a telemetry event
          * @param {string} eventName The event name
          * @param {object} properties An associative array of strings
          * @param {object} measures An associative array of numbers
          */
-        sendTelemetryEvent(eventName: string, properties?: {
+        // tslint:disable-next-line:member-access
+        public sendTelemetryEvent(eventName: string, properties?: {
             [key: string]: string;
         }, measures?: {
             [key: string]: number;
+            // tslint:disable-next-line:no-empty
         }): void;
     }
-}
+}

src/client/common/utils.ts

@@ -423,7 +423,7 @@ export function areBasePathsSame(path1: string, path2: string) {
     path2 = IS_WINDOWS ? path2.replace(/\//g, "\\") : path2;
     return path.dirname(path1).toUpperCase() === path.dirname(path2).toUpperCase();
 }
-export async function getInterpreterDisplayName(pythonPath: string) {
+export async function getInterpreterVersion(pythonPath: string) {
     return await new Promise<string>((resolve, reject) => {
         child_process.execFile(pythonPath, ['--version'], (error, stdout, stdErr) => {
             const out = (typeof stdErr === 'string' ? stdErr : '') + os.EOL + (typeof stdout === 'string' ? stdout : '');