flow analytics against vscode apis (#21)

akosyakov · jeanp413 · web-flow · commit 5c316131af30 · 2022-09-11T18:05:22.000-05:00
Co-authored-by: Jean Pierre &lt;jeanp413@hotmail.com&gt;
diff --git a/src/authentication.ts b/src/authentication.ts
@@ -12,6 +12,8 @@ import Log from './common/logger';
 import { arrayEquals } from './common/utils';
 import { Disposable } from './common/dispose';
 import TelemetryReporter from './telemetryReporter';
+import { UserFlowTelemetry } from './common/telemetry';
+import { NotificationService } from './notification';
 
 interface SessionData {
 	id: string;
@@ -28,35 +30,30 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 	private _sessionChangeEmitter = new vscode.EventEmitter<vscode.AuthenticationProviderAuthenticationSessionsChangeEvent>();
 	private _logger: Log;
 	private _telemetry: TelemetryReporter;
-	private _gitpodServer: GitpodServer;
-	private _keychain: Keychain;
 
-	private _serviceUrl: string;
+	private _gitpodServer!: GitpodServer;
+	private _keychain!: Keychain;
+	private _serviceUrl!: string;
 
 	private _sessionsPromise: Promise<vscode.AuthenticationSession[]>;
 
-	constructor(private readonly context: vscode.ExtensionContext, logger: Log, telemetry: TelemetryReporter) {
+	private readonly flow: Readonly<UserFlowTelemetry> = { flow: 'auth' };
+
+	constructor(
+		private readonly context: vscode.ExtensionContext,
+		logger: Log,
+		telemetry: TelemetryReporter,
+		private readonly notifications: NotificationService
+	) {
 		super();
 
 		this._logger = logger;
 		this._telemetry = telemetry;
 
-		const gitpodHost = vscode.workspace.getConfiguration('gitpod').get<string>('host')!;
-		const gitpodHostUrl = new URL(gitpodHost);
-		this._serviceUrl = gitpodHostUrl.toString().replace(/\/$/, '');
-		this._gitpodServer = new GitpodServer(this._serviceUrl, this._logger);
-		this._keychain = new Keychain(this.context, `gitpod.auth.${gitpodHostUrl.hostname}`, this._logger);
-		this._logger.info(`Started authentication provider for ${gitpodHost}`);
+		this.reconcile();
 		this._register(vscode.workspace.onDidChangeConfiguration(e => {
 			if (e.affectsConfiguration('gitpod.host')) {
-				const gitpodHost = vscode.workspace.getConfiguration('gitpod').get<string>('host')!;
-				const gitpodHostUrl = new URL(gitpodHost);
-				this._serviceUrl = gitpodHostUrl.toString().replace(/\/$/, '');
-				this._gitpodServer.dispose();
-				this._gitpodServer = new GitpodServer(this._serviceUrl, this._logger);
-				this._keychain = new Keychain(this.context, `gitpod.auth.${gitpodHostUrl.hostname}`, this._logger);
-				this._logger.info(`Started authentication provider for ${gitpodHost}`);
-
+				this.reconcile();
 				this.checkForUpdates();
 			}
 		}));
@@ -68,6 +65,17 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 		this._register(this.context.secrets.onDidChange(() => this.checkForUpdates()));
 	}
 
+	private reconcile(): void {
+		const gitpodHost = vscode.workspace.getConfiguration('gitpod').get<string>('host')!;
+		const gitpodHostUrl = new URL(gitpodHost);
+		this._serviceUrl = gitpodHostUrl.toString().replace(/\/$/, '');
+		Object.assign(this.flow, { gitpodHost: this._serviceUrl });
+		this._gitpodServer?.dispose();
+		this._gitpodServer = new GitpodServer(this._serviceUrl, this._logger, this.notifications);
+		this._keychain = new Keychain(this.context, `gitpod.auth.${gitpodHostUrl.hostname}`, this._logger);
+		this._logger.info(`Started authentication provider for ${gitpodHost}`);
+	}
+
 	get onDidChangeSessions() {
 		return this._sessionChangeEmitter.event;
 	}
@@ -213,6 +221,7 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 	}
 
 	public async createSession(scopes: string[]): Promise<vscode.AuthenticationSession> {
+		const flow = { ...this.flow };
 		try {
 			// For the Gitpod scope list, order doesn't matter so we immediately sort the scopes
 			const sortedScopes = scopes.sort();
@@ -221,15 +230,13 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 			if (sortedScopes.length !== sortedFilteredScopes.length) {
 				this._logger.warn(`Creating session with only valid scopes ${sortedFilteredScopes.join(',')}, original scopes were ${sortedScopes.join(',')}`);
 			}
-
-			this._telemetry.sendRawTelemetryEvent('gitpod_desktop_auth', {
-				kind: 'login',
-				scopes: JSON.stringify(sortedFilteredScopes),
-			});
+			flow.scopes = JSON.stringify(sortedFilteredScopes);
+			this._telemetry.sendUserFlowStatus('login', flow);
 
 			const scopeString = sortedFilteredScopes.join(' ');
-			const token = await this._gitpodServer.login(scopeString);
+			const token = await this._gitpodServer.login(scopeString, flow);
 			const session = await this.tokenToSession(token, sortedFilteredScopes);
+			flow.userId = session.account.id;
 
 			const sessions = await this._sessionsPromise;
 			const sessionIndex = sessions.findIndex(s => s.id === session.id || arrayEquals([...s.scopes].sort(), sortedFilteredScopes));
@@ -244,19 +251,16 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 
 			this._logger.info('Login success!');
 
-			this._telemetry.sendRawTelemetryEvent('gitpod_desktop_auth', { kind: 'login_successful' });
+			this._telemetry.sendUserFlowStatus('login_successful', flow);
 
 			return session;
 		} catch (e) {
 			// If login was cancelled, do not notify user.
 			if (e === 'Cancelled' || e.message === 'Cancelled') {
-				this._telemetry.sendRawTelemetryEvent('gitpod_desktop_auth', { kind: 'login_cancelled' });
+				this._telemetry.sendUserFlowStatus('login_cancelled', flow);
 				throw e;
 			}
-
-			this._telemetry.sendRawTelemetryEvent('gitpod_desktop_auth', { kind: 'login_failed' });
-
-			vscode.window.showErrorMessage(`Sign in failed: ${e}`);
+			this.notifications.showErrorMessage(`Sign in failed: ${e}`, { flow, id: 'login_failed' });
 			this._logger.error(e);
 			throw e;
 		}
@@ -273,15 +277,16 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 	}
 
 	public async removeSession(id: string) {
+		const flow = { ...this.flow };
 		try {
-			this._telemetry.sendRawTelemetryEvent('gitpod_desktop_auth', { kind: 'logout' });
-
+			this._telemetry.sendUserFlowStatus('logout', flow);
 			this._logger.info(`Logging out of ${id}`);
 
 			const sessions = await this._sessionsPromise;
 			const sessionIndex = sessions.findIndex(session => session.id === id);
 			if (sessionIndex > -1) {
 				const session = sessions[sessionIndex];
+				flow.userId = session.account.id;
 				sessions.splice(sessionIndex, 1);
 
 				await this.storeSessions(sessions);
@@ -290,10 +295,9 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 			} else {
 				this._logger.error('Session not found');
 			}
+			this._telemetry.sendUserFlowStatus('logout_successful', flow);
 		} catch (e) {
-			this._telemetry.sendRawTelemetryEvent('gitpod_desktop_auth', { kind: 'logout_failed' });
-
-			vscode.window.showErrorMessage(`Sign out failed: ${e}`);
+			this.notifications.showErrorMessage(`Sign out failed: ${e}`, { flow, id: 'logout_failed' });
 			this._logger.error(e);
 			throw e;
 		}
diff --git a/src/common/telemetry.ts b/src/common/telemetry.ts
@@ -8,6 +8,22 @@
 import * as vscode from 'vscode';
 import { Disposable } from './dispose';
 
+export interface TelemetryOptions {
+	gitpodHost?: string;
+	gitpodVersion?: string;
+
+	workspaceId?: string;
+	instanceId?: string;
+
+	userId?: string
+
+	[prop: string]: any
+}
+
+export interface UserFlowTelemetry extends TelemetryOptions {
+	flow: string
+}
+
 const enum TelemetryLevel {
 	ON = 'on',
 	ERROR = 'error',
@@ -373,6 +389,12 @@ export class BaseTelemetryReporter extends Disposable {
 		}
 	}
 
+	sendUserFlowStatus(status: string, flow: UserFlowTelemetry): void {
+		const properties: TelemetryOptions = { ...flow, status };
+		delete properties['flow'];
+		this.sendRawTelemetryEvent('vscode_desktop_' + flow.flow, properties);
+	}
+
 	/**
 	 * Given an event name, some properties, and measurements sends a raw (unsanitized) telemetry event
 	 * @param eventName The name of the event
diff --git a/src/experiments.ts b/src/experiments.ts
@@ -10,7 +10,8 @@ import * as semver from 'semver';
 import Log from './common/logger';
 
 const EXPERTIMENTAL_SETTINGS = [
-    'gitpod.remote.useLocalApp'
+    'gitpod.remote.useLocalApp',
+    'gitpod.remote.syncExtensions'
 ];
 
 export class ExperimentalSettings {
diff --git a/src/extension.ts b/src/extension.ts
@@ -5,15 +5,17 @@
 
 import * as os from 'os';
 import * as vscode from 'vscode';
-import Log from './common/logger';
 import GitpodAuthenticationProvider from './authentication';
+import Log from './common/logger';
+import { UserFlowTelemetry } from './common/telemetry';
+import { ExperimentalSettings } from './experiments';
+import { exportLogs } from './exportLogs';
+import GitpodServer from './gitpodServer';
+import { NotificationService } from './notification';
+import { ReleaseNotes } from './releaseNotes';
 import RemoteConnector from './remoteConnector';
 import { SettingsSync } from './settingsSync';
-import GitpodServer from './gitpodServer';
 import TelemetryReporter from './telemetryReporter';
-import { exportLogs } from './exportLogs';
-import { ReleaseNotes } from './releaseNotes';
-import { ExperimentalSettings } from './experiments';
 
 const FIRST_INSTALL_KEY = 'gitpod-desktop.firstInstall';
 
@@ -34,22 +36,26 @@ export async function activate(context: vscode.ExtensionContext) {
 	context.subscriptions.push(experiments);
 
 	telemetry = new TelemetryReporter(extensionId, packageJSON.version, packageJSON.segmentKey);
+	const notifications = new NotificationService(telemetry);
 
 	context.subscriptions.push(vscode.commands.registerCommand('gitpod.exportLogs', async () => {
+		const flow: UserFlowTelemetry = { flow: 'export_logs' };
+		telemetry.sendUserFlowStatus('exporting', flow);
 		try {
 			await exportLogs(context);
+			telemetry.sendUserFlowStatus('exported', flow);
 		} catch (e) {
 			const outputMessage = `Error exporting logs: ${e}`;
-			vscode.window.showErrorMessage(outputMessage);
+			notifications.showErrorMessage(outputMessage, { id: 'failed', flow });
 			logger.error(outputMessage);
 		}
 	}));
 
-	const settingsSync = new SettingsSync(logger, telemetry);
+	const settingsSync = new SettingsSync(logger, telemetry, notifications);
 	context.subscriptions.push(settingsSync);
 
-	const authProvider = new GitpodAuthenticationProvider(context, logger, telemetry);
-	remoteConnector = new RemoteConnector(context, settingsSync, experiments, logger, telemetry);
+	const authProvider = new GitpodAuthenticationProvider(context, logger, telemetry, notifications);
+	remoteConnector = new RemoteConnector(context, settingsSync, experiments, logger, telemetry, notifications);
 	context.subscriptions.push(authProvider);
 	context.subscriptions.push(vscode.window.registerUriHandler({
 		handleUri(uri: vscode.Uri) {
diff --git a/src/gitpodServer.ts b/src/gitpodServer.ts
@@ -11,6 +11,8 @@ import { withServerApi } from './internalApi';
 import pkceChallenge from 'pkce-challenge';
 import { v4 as uuid } from 'uuid';
 import { Disposable } from './common/dispose';
+import { NotificationService } from './notification';
+import { UserFlowTelemetry } from './common/telemetry';
 
 interface ExchangeTokenResponse {
 	token_type: 'Bearer';
@@ -38,13 +40,17 @@ export default class GitpodServer extends Disposable {
 	private _codeExchangePromises = new Map<string, { promise: Promise<string>; cancel: vscode.EventEmitter<void> }>();
 	private _uriEmitter = this._register(new vscode.EventEmitter<vscode.Uri>());
 
-	constructor(serviceUrl: string, private readonly _logger: Log) {
+	constructor(
+		serviceUrl: string,
+		private readonly _logger: Log,
+		private readonly notifications: NotificationService
+	) {
 		super();
 
 		this._serviceUrl = serviceUrl.replace(/\/$/, '');
 	}
 
-	public async login(scopes: string): Promise<string> {
+	public async login(scopes: string, flow: UserFlowTelemetry): Promise<string> {
 		this._logger.info(`Logging in for the following scopes: ${scopes}`);
 
 		const callbackUri = await vscode.env.asExternalUri(vscode.Uri.parse(`${vscode.env.uriScheme}://gitpod.gitpod-desktop/complete-gitpod-auth`));
@@ -78,7 +84,7 @@ export default class GitpodServer extends Disposable {
 			// before completing it.
 			let codeExchangePromise = this._codeExchangePromises.get(scopes);
 			if (!codeExchangePromise) {
-				codeExchangePromise = promiseFromEvent(this._uriEmitter.event, this.exchangeCodeForToken(scopes));
+				codeExchangePromise = promiseFromEvent(this._uriEmitter.event, this.exchangeCodeForToken(scopes, flow));
 				this._codeExchangePromises.set(scopes, codeExchangePromise);
 			}
 
@@ -97,8 +103,8 @@ export default class GitpodServer extends Disposable {
 		});
 	}
 
-	private exchangeCodeForToken: (scopes: string) => PromiseAdapter<vscode.Uri, string> =
-		(scopes) => async (uri, resolve, reject) => {
+	private exchangeCodeForToken: (scopes: string, flow: UserFlowTelemetry) => PromiseAdapter<vscode.Uri, string> =
+		(scopes, flow) => async (uri, resolve, reject) => {
 			const query = new URLSearchParams(uri.query);
 			const code = query.get('code');
 			const state = query.get('state');
@@ -146,7 +152,7 @@ export default class GitpodServer extends Disposable {
 				});
 
 				if (!exchangeTokenResponse.ok) {
-					vscode.window.showErrorMessage(`Couldn't connect (token exchange): ${exchangeTokenResponse.statusText}, ${await exchangeTokenResponse.text()}`);
+					this.notifications.showErrorMessage(`Couldn't connect (token exchange): ${exchangeTokenResponse.statusText}, ${await exchangeTokenResponse.text()}`, { flow, id: 'failed_to_exchange' });
 					reject(exchangeTokenResponse.statusText);
 					return;
 				}
@@ -156,6 +162,7 @@ export default class GitpodServer extends Disposable {
 				const accessToken = JSON.parse(Buffer.from(jwtToken.split('.')[1], 'base64').toString())['jti'];
 				resolve(accessToken);
 			} catch (err) {
+				this.notifications.showErrorMessage(`Couldn't connect (token exchange): ${err}`, { flow, id: 'failed_to_exchange' });
 				reject(err);
 			}
 		};
diff --git a/src/notification.ts b/src/notification.ts
@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Gitpod. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { UserFlowTelemetry } from './common/telemetry';
+import TelemetryReporter from './telemetryReporter';
+
+export interface NotificationOption extends vscode.MessageOptions {
+    id: string
+    flow: UserFlowTelemetry
+}
+
+export class NotificationService {
+
+    constructor(
+        private readonly telemetry: TelemetryReporter
+    ) { }
+
+    showInformationMessage<T extends vscode.MessageItem | string>(message: string, option: NotificationOption, ...items: T[]): Promise<T | undefined> {
+        return this.withTelemetry<T>(option, 'info', () =>
+            vscode.window.showInformationMessage(message, option, ...<any[]>items)
+        );
+    }
+
+    showWarningMessage<T extends vscode.MessageItem | string>(message: string, option: NotificationOption, ...items: T[]): Promise<T | undefined> {
+        return this.withTelemetry<T>(option, 'warning', () =>
+            vscode.window.showWarningMessage(message, option, ...<any[]>items)
+        );
+    }
+
+    showErrorMessage<T extends vscode.MessageItem | string>(message: string, option: NotificationOption, ...items: T[]): Promise<T | undefined> {
+        return this.withTelemetry<T>(option, 'error', () =>
+            vscode.window.showErrorMessage(message, option, ...<any[]>items)
+        );
+    }
+
+    private async withTelemetry<T extends vscode.MessageItem | string>(option: NotificationOption, severity: 'info' | 'warning' | 'error', cb: () => PromiseLike<T | undefined>): Promise<T | undefined> {
+        const startTime = new Date().getTime();
+        let element = option.id;
+        if (option.modal === true) {
+            element += '_modal';
+        } else {
+            element += '_notification';
+        }
+        const flowOptions = { ...option.flow, severity };
+        this.telemetry.sendUserFlowStatus('show_' + element, flowOptions);
+        let result: T | undefined;
+        try {
+            result = await cb();
+        } finally {
+            const duration = new Date().getTime() - startTime;
+            const closed = result === undefined || (typeof result === 'object' && result.isCloseAffordance == true);
+            const status = closed ? 'close_' + element : 'select_' + element + '_action';
+            const action = typeof result === 'string' ? result : result?.title;
+            this.telemetry.sendUserFlowStatus(status, { ...flowOptions, action, duration });
+        }
+        return result;
+    }
+
+}
diff --git a/src/remoteConnector.ts b/src/remoteConnector.ts
diff --git a/src/settingsSync.ts b/src/settingsSync.ts
