Implement telemetry reporting in extension (microsoft#2613)

Author: DanielRosenwasser

_extension/package.json

@@ -160,6 +160,7 @@
         "bundle:release": "npm run bundle -- --minify"
     },
     "dependencies": {
+        "@vscode/extension-telemetry": "^1.2.0",
         "vscode-languageclient": "^10.0.0-next.19"
     },
     "devDependencies": {

_extension/src/client.ts

@@ -1,14 +1,23 @@
 import * as vscode from "vscode";
+
 import {
+    CloseAction,
+    CloseHandlerResult,
+    ErrorAction,
+    ErrorHandler,
+    ErrorHandlerResult,
     LanguageClient,
     LanguageClientOptions,
+    Message,
     NotebookDocumentFilter,
     ServerOptions,
     TextDocumentFilter,
     TransportKind,
 } from "vscode-languageclient/node";
+
 import { codeLensShowLocationsCommandName } from "./commands";
 import { registerTagClosingFeature } from "./languageFeatures/tagClosing";
+import * as tr from "./telemetryReporting";
 import {
     ExeInfo,
     getExe,
@@ -19,6 +28,8 @@ import { getLanguageForUri } from "./util";
 export class Client {
     private outputChannel: vscode.LogOutputChannel;
     private traceOutputChannel: vscode.LogOutputChannel;
+    private telemetryReporter: tr.TelemetryReporter;
+
     private documentSelector: Array<{ scheme: string; language: string; }>;
     private clientOptions: LanguageClientOptions;
     private client?: LanguageClient;
@@ -29,9 +40,10 @@ export class Client {
     private exe: ExeInfo | undefined;
     private onStartedCallbacks: Set<() => void> = new Set();
 
-    constructor(outputChannel: vscode.LogOutputChannel, traceOutputChannel: vscode.LogOutputChannel) {
+    constructor(outputChannel: vscode.LogOutputChannel, traceOutputChannel: vscode.LogOutputChannel, telemetryReporter: tr.TelemetryReporter) {
         this.outputChannel = outputChannel;
         this.traceOutputChannel = traceOutputChannel;
+        this.telemetryReporter = telemetryReporter;
         this.documentSelector = [
             ...jsTsLanguageModes.map(language => ({ scheme: "file", language })),
             ...jsTsLanguageModes.map(language => ({ scheme: "untitled", language })),
@@ -43,6 +55,7 @@ export class Client {
             initializationOptions: {
                 codeLensShowLocationsCommandName,
             },
+            errorHandler: new ReportingErrorHandler(this.telemetryReporter, 5),
             diagnosticPullOptions: {
                 onChange: true,
                 onSave: true,
@@ -100,6 +113,9 @@ export class Client {
     async start(context: vscode.ExtensionContext, exe: { path: string; version: string; }): Promise<vscode.Disposable> {
         this.exe = exe;
         this.outputChannel.appendLine(`Resolved to ${this.exe.path}`);
+        this.telemetryReporter.sendTelemetryEvent("languageServer.start", {
+            version: this.exe.version,
+        });
 
         // Get pprofDir
         const config = vscode.workspace.getConfiguration("typescript.native-preview");
@@ -150,7 +166,32 @@ export class Client {
             this.traceOutputChannel.appendLine(`To see LSP trace output, set this output's log level to "Trace" (gear icon next to the dropdown).`);
         }
 
+        type TelemetryData = {
+            eventName: string;
+            telemetryPurpose: "usage" | "error";
+            properties?: Record<string, string>;
+            measurements?: Record<string, number>;
+        };
+
+        const serverTelemetryListener = this.client.onTelemetry((d: TelemetryData) => {
+            switch (d.telemetryPurpose) {
+                case "usage":
+                    this.telemetryReporter.sendTelemetryEventUntyped(d.eventName, d.properties, d.measurements);
+                    break;
+                case "error":
+                    this.telemetryReporter.sendTelemetryErrorEventUntyped(d.eventName, d.properties, d.measurements);
+                    break;
+                default:
+                    const _: never = d.telemetryPurpose;
+                    this.telemetryReporter.sendTelemetryErrorEvent("languageServer.unexpectedTelemetryPurpose", {
+                        telemetryPurpose: String(d.telemetryPurpose),
+                    });
+                    break;
+            }
+        });
+
         this.disposables.push(
+            serverTelemetryListener,
             registerTagClosingFeature("typescript", this.documentSelector, this.client),
             registerTagClosingFeature("javascript", this.documentSelector, this.client),
         );
@@ -186,6 +227,7 @@ export class Client {
         }
 
         this.onStartedCallbacks.add(callback);
+
         return new vscode.Disposable(() => {
             this.onStartedCallbacks.delete(callback);
         });
@@ -247,3 +289,83 @@ export class Client {
         return result.file;
     }
 }
+
+// Adapted from the default error handler in vscode-languageclient.
+class ReportingErrorHandler implements ErrorHandler {
+    telemetryReporter: tr.TelemetryReporter;
+    maxRestartCount: number;
+    restarts: number[];
+
+    constructor(telemetryReporter: tr.TelemetryReporter, maxRestartCount: number) {
+        this.telemetryReporter = telemetryReporter;
+        this.maxRestartCount = maxRestartCount;
+        this.restarts = [];
+    }
+
+    error(_error: Error, _message: Message | undefined, count: number | undefined): ErrorHandlerResult | Promise<ErrorHandlerResult> {
+        let errorAction = ErrorAction.Shutdown;
+        if (count && count <= 3) {
+            errorAction = ErrorAction.Continue;
+        }
+
+        let actionString = "";
+        switch (errorAction) {
+            case ErrorAction.Continue:
+                actionString = "continue";
+                break;
+            case ErrorAction.Shutdown:
+                actionString = "shutdown";
+                break;
+            default:
+                const _: never = errorAction;
+        }
+        this.telemetryReporter.sendTelemetryErrorEvent("languageServer.connectionError", {
+            resultingAction: actionString,
+        });
+
+        return { action: errorAction };
+    }
+
+    closed(): CloseHandlerResult | Promise<CloseHandlerResult> {
+        let resultingAction: CloseAction;
+
+        this.restarts.push(Date.now());
+        if (this.restarts.length <= this.maxRestartCount) {
+            resultingAction = CloseAction.Restart;
+        }
+        else {
+            const diff = this.restarts[this.restarts.length - 1] - this.restarts[0];
+            if (diff <= 3 * 60 * 1000) {
+                resultingAction = CloseAction.DoNotRestart;
+            }
+            else {
+                this.restarts.shift();
+                resultingAction = CloseAction.Restart;
+            }
+        }
+
+        let actionString = "";
+        switch (resultingAction) {
+            case CloseAction.DoNotRestart:
+                actionString = "doNotRestart";
+                break;
+            case CloseAction.Restart:
+                actionString = "restart";
+                break;
+            default:
+                const _: never = resultingAction;
+        }
+        this.telemetryReporter.sendTelemetryErrorEvent("languageServer.connectionClosed", {
+            resultingAction: actionString,
+        });
+
+        if (resultingAction === CloseAction.DoNotRestart) {
+            return {
+                action: resultingAction,
+                message: `The typescript.native-preview-lsp server crashed ${this.maxRestartCount + 1} times in the last 3 minutes. The server will not be restarted. See the output for more information.`,
+            };
+        }
+
+        return { action: resultingAction };
+    }
+}

_extension/src/commands.ts

@@ -1,29 +1,40 @@
 import * as vscode from "vscode";
+
 import type {
     DocumentUri,
     Location,
     Position,
 } from "vscode-languageclient";
 
 import { Client } from "./client";
+import type * as tr from "./telemetryReporting";
 import { restartExtHostOnChangeIfNeeded } from "./util";
 
-export function registerEnablementCommands(context: vscode.ExtensionContext): void {
+export function registerEnablementCommands(context: vscode.ExtensionContext, telemetryReporter: tr.TelemetryReporter): void {
     context.subscriptions.push(vscode.commands.registerCommand("typescript.native-preview.enable", () => {
         // Fire and forget, because this will restart the extension host and cause an error if we await
+        telemetryReporter.sendTelemetryEvent("command.enableNativePreview");
         updateUseTsgoSetting(true);
     }));
 
     context.subscriptions.push(vscode.commands.registerCommand("typescript.native-preview.disable", () => {
         // Fire and forget, because this will restart the extension host and cause an error if we await
+        telemetryReporter.sendTelemetryEvent("command.disableNativePreview");
         updateUseTsgoSetting(false);
     }));
 }
 
-export function registerLanguageCommands(context: vscode.ExtensionContext, client: Client, outputChannel: vscode.OutputChannel, traceOutputChannel: vscode.OutputChannel): vscode.Disposable[] {
+export function registerLanguageCommands(
+    context: vscode.ExtensionContext,
+    client: Client,
+    outputChannel: vscode.OutputChannel,
+    traceOutputChannel: vscode.OutputChannel,
+    telemetryReporter: tr.TelemetryReporter,
+): vscode.Disposable[] {
     const disposables: vscode.Disposable[] = [];
 
     disposables.push(vscode.commands.registerCommand("typescript.native-preview.restart", () => {
+        telemetryReporter.sendTelemetryEvent("command.restartLanguageServer");
         return client.restart(context);
     }));
 
@@ -41,6 +52,7 @@ export function registerLanguageCommands(context: vscode.ExtensionContext, clien
     disposables.push(vscode.commands.registerCommand("typescript.native-preview.showMenu", showCommands));
 
     disposables.push(vscode.commands.registerCommand("typescript.native-preview.reportIssue", () => {
+        telemetryReporter.sendTelemetryEvent("command.reportIssue");
         vscode.commands.executeCommand("workbench.action.openIssueReporter", {
             extensionId: "TypeScriptTeam.native-preview",
         });

_extension/src/extension.ts

@@ -7,12 +7,26 @@ import {
     registerLanguageCommands,
 } from "./commands";
 import { setupStatusBar } from "./statusBar";
-import { needsExtHostRestartOnChange } from "./util";
+import {
+    aiConnectionString,
+    needsExtHostRestartOnChange,
+} from "./util";
 import { setupVersionStatusItem } from "./versionStatusItem";
 
+import { TelemetryReporter as VSCodeTelemetryReporter } from "@vscode/extension-telemetry";
+import {
+    createTelemetryReporter,
+    TelemetryReporter,
+} from "./telemetryReporting";
+
 export async function activate(context: vscode.ExtensionContext) {
     await vscode.commands.executeCommand("setContext", "typescript.native-preview.serverRunning", false);
-    registerEnablementCommands(context);
+
+    const telemetryReporter = createTelemetryReporter(new VSCodeTelemetryReporter(aiConnectionString));
+    context.subscriptions.push(telemetryReporter);
+
+    registerEnablementCommands(context, telemetryReporter);
+
     const output = vscode.window.createOutputChannel("typescript-native-preview", { log: true });
     const traceOutput = vscode.window.createOutputChannel("typescript-native-preview (LSP)", { log: true });
     context.subscriptions.push(output, traceOutput);
@@ -34,7 +48,7 @@ export async function activate(context: vscode.ExtensionContext) {
             else {
                 const useTsgo = vscode.workspace.getConfiguration("typescript").get<boolean>("experimental.useTsgo");
                 if (useTsgo) {
-                    disposeLanguageFeatures = await activateLanguageFeatures(context, output, traceOutput);
+                    disposeLanguageFeatures = await activateLanguageFeatures(context, output, traceOutput, telemetryReporter);
                     context.subscriptions.push(disposeLanguageFeatures);
                 }
                 else {
@@ -74,15 +88,20 @@ export async function activate(context: vscode.ExtensionContext) {
         return;
     }
 
-    disposeLanguageFeatures = await activateLanguageFeatures(context, output, traceOutput);
+    disposeLanguageFeatures = await activateLanguageFeatures(context, output, traceOutput, telemetryReporter);
     context.subscriptions.push(disposeLanguageFeatures);
 }
 
-async function activateLanguageFeatures(context: vscode.ExtensionContext, output: vscode.LogOutputChannel, traceOutput: vscode.LogOutputChannel): Promise<vscode.Disposable> {
+async function activateLanguageFeatures(
+    context: vscode.ExtensionContext,
+    output: vscode.LogOutputChannel,
+    traceOutput: vscode.LogOutputChannel,
+    telemetryReporter: TelemetryReporter,
+): Promise<vscode.Disposable> {
     const disposables: vscode.Disposable[] = [];
 
-    const client = new Client(output, traceOutput);
-    disposables.push(...registerLanguageCommands(context, client, output, traceOutput));
+    const client = new Client(output, traceOutput, telemetryReporter);
+    disposables.push(...registerLanguageCommands(context, client, output, traceOutput, telemetryReporter));
     disposables.push(await client.initialize(context));
     disposables.push(setupStatusBar());
     disposables.push(...setupVersionStatusItem(client));

_extension/src/telemetryReporting.ts

@@ -0,0 +1,77 @@
+import type { TelemetryReporter as VSCodeTelemetryReporter } from "@vscode/extension-telemetry";
+
+// As new events are added, update the TelemetryReporter interface below.
+// This helps ensure that the telemetry events used in the codebase are
+// properly typed, and that properties/measurements are never forgotten.
+//
+// The difference between `sendTelemetryEvent` and `sendTelemetryErrorEvent` is that
+// these methods respect user preferences around reporting (i.e. `telemetry.telemetryLevel`).
+//
+// The "untyped" variants are provided for when properties/measurements are not known
+// from the editor client - for example, when forwarding telemetry events from the language server.
+export interface TelemetryReporter {
+    sendTelemetryEvent(eventName: "command.enableNativePreview"): void;
+    sendTelemetryEvent(eventName: "command.disableNativePreview"): void;
+    sendTelemetryEvent(eventName: "command.restartLanguageServer"): void;
+    sendTelemetryEvent(eventName: "command.reportIssue"): void;
+    sendTelemetryEvent(eventName: "languageServer.start", data: LSServerStart): void;
+
+    sendTelemetryErrorEvent(eventName: "languageServer.connectionError", data: LSConnectionError): void;
+    sendTelemetryErrorEvent(eventName: "languageServer.connectionClosed", data: LSServerConnectionClosed): void;
+    sendTelemetryErrorEvent(eventName: "languageServer.errorResponse", data: LSErrorResponse): void;
+    sendTelemetryErrorEvent(eventName: "languageServer.unexpectedTelemetryPurpose", data: UnexpectedTelemetryPurpose): void;
+
+    sendTelemetryEventUntyped(eventName: string, data?: Record<string, string>, measurements?: Record<string, number>): void;
+    sendTelemetryErrorEventUntyped(eventName: string, data?: Record<string, string>, measurements?: Record<string, number>): void;
+
+    dispose(): void;
+}
+
+export function createTelemetryReporter(vscReporter: VSCodeTelemetryReporter): TelemetryReporter {
+    return {
+        sendTelemetryEvent,
+        sendTelemetryErrorEvent,
+        sendTelemetryEventUntyped: sendTelemetryEvent,
+        sendTelemetryErrorEventUntyped: sendTelemetryErrorEvent,
+
+        dispose: () => vscReporter.dispose(),
+    };
+
+    function sendTelemetryEvent(eventName: string, data?: Record<string, string>, measurements?: Record<string, number>): void {
+        vscReporter.sendTelemetryEvent(eventName, data, measurements);
+    }
+
+    function sendTelemetryErrorEvent(eventName: string, data?: Record<string, string>, measurements?: Record<string, number>): void {
+        vscReporter.sendTelemetryErrorEvent(eventName, data, measurements);
+    }
+}
+
+export type LSServerStart = {
+    version: string;
+};
+
+export type LSConnectionError = {
+    resultingAction: string;
+};
+
+export type LSServerConnectionClosed = {
+    resultingAction: string;
+};
+
+export type LSErrorResponse = {
+    errorCode: string;
+    requestMethod: string;
+    stack: string;
+};
+
+export type EnableNativePreview = {};
+
+export type DisableNativePreview = {};
+
+export type RestartLanguageServer = {};
+
+export type ReportIssue = {};
+
+export type UnexpectedTelemetryPurpose = {
+    telemetryPurpose: string;
+};

_extension/src/util.ts

@@ -4,6 +4,8 @@ import packageJson from "../package.json";
 
 const version = packageJson.version;
 
+export const aiConnectionString = "0c6ae279ed8443289764825290e4f9e2-1a736e7c-1324-4338-be46-fc2a58ae4d14-7255";
+
 export const jsTsLanguageModes = [
     "typescript",
     "typescriptreact",