Send proper telemetry when copy needed files (#69)

mustard-mh · web-flow · commit 67f1a3e2b3aa · 2023-05-31T23:20:09.000+08:00
* Move file copy telemetry inside LocalSSHService

* fix compile

* Respond with correct error message when exception

* Add failure code to copy file telemetry

* downgrade configcat

* Wrap errors

* 💄

* 💄

* 💄
diff --git a/package.json b/package.json
@@ -3,7 +3,7 @@
 	"displayName": "Gitpod",
 	"description": "Gitpod Support",
 	"publisher": "gitpod",
- 	"version": "0.0.112",
+	"version": "0.0.112",
 	"daemonVersion": "0.0.9",
 	"license": "MIT",
 	"icon": "resources/gitpod.png",
diff --git a/src/common/files.ts b/src/common/files.ts
@@ -26,6 +26,15 @@ export async function isFile(path: string) {
     }
 }
 
+export async function isDir(path: string) {
+    try {
+        const s = await fs.promises.stat(path);
+        return s.isDirectory();
+    } catch {
+        return false;
+    }
+}
+
 export function untildify(path: string){
 	return path.replace(/^~(?=$|\/|\\)/, homeDir);
 }
diff --git a/src/common/utils.ts b/src/common/utils.ts
@@ -124,3 +124,16 @@ export function arrayEquals<T>(one: ReadonlyArray<T> | undefined, other: Readonl
 export function getServiceURL(gitpodHost: string): string {
 	return new URL(gitpodHost).toString().replace(/\/$/, '');
 }
+
+export class WrapError extends Error {
+	code: string | undefined;
+	constructor(msg: string, err: any, code?: string) {
+		super(msg);
+		if (err instanceof Error) {
+			this.name = err.name;
+			this.stack = err.stack;
+			this.message = `${msg}: ${err.message}`;
+		}
+		this.code = code ? code : err.code;
+	}
+}
diff --git a/src/configuration.ts b/src/configuration.ts
@@ -13,10 +13,7 @@ function getGitpodHost() {
     return vscode.workspace.getConfiguration('gitpod').get<string>('host', 'https://gitpod.io/');
 }
 
-function getUseLocalApp(useLocalSSHServer?: boolean) {
-    if (useLocalSSHServer) {
-        return false;
-    }
+function getUseLocalApp() {
     return vscode.workspace.getConfiguration('gitpod').get<boolean>('remote.useLocalApp', false);
 }
 
diff --git a/src/experiments.ts b/src/experiments.ts
@@ -64,7 +64,6 @@ export class ExperimentalSettings extends Disposable {
     async getRaw<T>(
         configcatKey: string,
         custom: {
-            gitpodHost: string;
             [key: string]: string;
         }
     ) {
@@ -140,8 +139,8 @@ export class ExperimentalSettings extends Disposable {
     /**
      * @see https://app.configcat.com/08da1258-64fb-4a8e-8a1e-51de773884f6/08da1258-6541-4fc7-8b61-c8b47f82f3a0/08da1258-6512-4ec0-80a3-3f6aa301f853?settingId=75503
      */
-    async getUseLocalSSHProxy(gitpodHost: string): Promise<boolean> {
-        return (await this.getRaw<boolean>('gitpod_desktop_use_local_ssh_proxy', { gitpodHost })) ?? false;
+    async getUseLocalSSHProxy(): Promise<boolean> {
+        return (await this.getRaw<boolean>('gitpod_desktop_use_local_ssh_proxy', {})) ?? false;
     }
 
     async getUsePublicAPI(gitpodHost: string): Promise<boolean> {
diff --git a/src/extension.ts b/src/extension.ts
@@ -72,12 +72,12 @@ export async function activate(context: vscode.ExtensionContext) {
 		hostService = new HostService(context, notificationService, logger);
 		context.subscriptions.push(hostService);
 
-		const localSSHService = new LocalSSHService(context, hostService, telemetryService, logger);
-		context.subscriptions.push(localSSHService);
-
 		const sessionService = new SessionService(hostService, logger);
 		context.subscriptions.push(sessionService);
 
+		const localSSHService = new LocalSSHService(context, hostService, telemetryService, sessionService, logger);
+		context.subscriptions.push(localSSHService);
+
 		const experiments = new ExperimentalSettings(packageJSON.configcatKey, packageJSON.version, context, sessionService, hostService, logger);
 		context.subscriptions.push(experiments);
 
diff --git a/src/local-ssh/ipc/extensionServiceServer.ts b/src/local-ssh/ipc/extensionServiceServer.ts
@@ -112,7 +112,7 @@ class ExtensionServiceImpl implements ExtensionServiceImplementation {
             };
         } catch (e) {
             this.logService.error(e, 'failed to get workspace auth info');
-            throw e;
+            throw new ServerError(Status.UNAVAILABLE, e.toString());
         }
     }
 
diff --git a/src/remoteConnector.ts b/src/remoteConnector.ts
@@ -687,10 +687,12 @@ export class RemoteConnector extends Disposable {
 				this.usePublicApi = await this.experiments.getUsePublicAPI(params.gitpodHost);
 				this.logService.info(`Going to use ${this.usePublicApi ? 'public' : 'server'} API`);
 
-				let useLocalSSH = await this.experiments.getUseLocalSSHProxy(params.gitpodHost);
+				let useLocalSSH = await this.experiments.getUseLocalSSHProxy();
 				if (useLocalSSH) {
+					// we need to update the remote ssh config first, since another call is too late for local-ssh
+					await this.updateRemoteSSHConfig(true, undefined);
+					this.localSSHService.flow = sshFlow;
 					await this.localSSHService.initialized;
-					this.telemetryService.sendUserFlowStatus(this.localSSHService.isSupportLocalSSH ? 'success' : 'failure', { ...sshFlow, flow: 'local_ssh_config' });
 					if (!this.localSSHService.isSupportLocalSSH) {
 						this.logService.error('Local SSH is not supported on this platform');
 						useLocalSSH = false;
@@ -700,7 +702,7 @@ export class RemoteConnector extends Disposable {
 					this.logService.info('Going to use lssh');
 				}
 
-				const forceUseLocalApp = Configuration.getUseLocalApp(useLocalSSH);
+				const forceUseLocalApp = Configuration.getUseLocalApp();
 				const userOverride = String(isUserOverrideSetting('gitpod.remote.useLocalApp'));
 				let sshDestination: SSHDestination | undefined;
 				if (!forceUseLocalApp) {
@@ -828,7 +830,7 @@ export class RemoteConnector extends Disposable {
 
 	public async autoTunnelCommand(gitpodHost: string, instanceId: string, enabled: boolean) {
 		if (this.sessionService.isSignedIn()) {
-			const forceUseLocalApp = Configuration.getUseLocalApp(await this.experiments.getUseLocalSSHProxy(gitpodHost));
+			const forceUseLocalApp = Configuration.getUseLocalApp();
 			if (!forceUseLocalApp) {
 				const authority = vscode.Uri.parse(gitpodHost).authority;
 				const configKey = `config/${authority}`;
diff --git a/src/remoteSession.ts b/src/remoteSession.ts
@@ -61,7 +61,7 @@ export class RemoteSession extends Disposable {
 		}
 
 		try {
-			const useLocalSSH = await this.experiments.getUseLocalSSHProxy(this.connectionInfo.gitpodHost);
+			const useLocalSSH = await this.experiments.getUseLocalSSHProxy();
 			if (useLocalSSH) {
 				this.extensionServiceServer = new ExtensionServiceServer(this.logService, this.sessionService, this.hostService, this.telemetryService, this.experiments);
 			}
diff --git a/src/services/localSSHService.ts b/src/services/localSSHService.ts
@@ -12,21 +12,28 @@ import { IHostService } from './hostService';
 import SSHConfiguration from '../ssh/sshConfig';
 import { isWindows } from '../common/platform';
 import { getLocalSSHDomain } from '../remote';
-import { ITelemetryService } from './telemetryService';
+import { ITelemetryService, UserFlowTelemetry } from './telemetryService';
+import { ISessionService } from './sessionService';
+import { WrapError } from '../common/utils';
 
 export interface ILocalSSHService {
+    flow?: UserFlowTelemetry;
     isSupportLocalSSH: boolean;
     initialized: Promise<void>;
 }
 
+type FailedToInitializeCode = 'Unknown' | string;
+
 export class LocalSSHService extends Disposable implements ILocalSSHService {
     public isSupportLocalSSH: boolean = false;
     public initialized: Promise<void>;
+    public flow?: UserFlowTelemetry;
     constructor(
         private readonly context: vscode.ExtensionContext,
         private readonly hostService: IHostService,
         private readonly telemetryService: ITelemetryService,
-        private readonly logService: ILogService
+        private readonly sessionService: ISessionService,
+        private readonly logService: ILogService,
     ) {
         super();
 
@@ -53,18 +60,26 @@ export class LocalSSHService extends Disposable implements ILocalSSHService {
     }
 
     private async initialize() {
+        let failureCode: FailedToInitializeCode | undefined;
+        const useLocalAPP = String(Configuration.getUseLocalApp());
         try {
             const locations = await this.copyProxyScript();
             await this.configureSettings(locations);
             this.isSupportLocalSSH = true;
         } catch (e) {
-            this.logService.error(e, 'failed to copy local ssh client.js');
-            if (e.message) {
-                e.message = `Failed to copy local ssh client.js: ${e.message}`;
+            this.logService.error(e, 'failed to initialize');
+            failureCode = 'Unknown';
+            if (e?.code) {
+                failureCode = e.code;
+            }
+            if (e?.message) {
+                e.message = `Failed to initialize: ${e.message}`;
             }
-            this.telemetryService.sendTelemetryException(this.hostService.gitpodHost, e);
+            this.telemetryService.sendTelemetryException(this.hostService.gitpodHost, e, { useLocalAPP });
             this.isSupportLocalSSH = false;
         }
+        const flowData = this.flow ? this.flow : { gitpodHost: this.hostService.gitpodHost, userId: this.sessionService.safeGetUserId() };
+        this.telemetryService.sendUserFlowStatus(this.isSupportLocalSSH ? 'success' : 'failure', { ...flowData, flow: 'local_ssh_config', failureCode, useLocalAPP });
     }
 
     private async configureSettings({ proxyScript, launcher }: { proxyScript: string; launcher: string }) {
@@ -85,14 +100,18 @@ export class LocalSSHService extends Disposable implements ILocalSSHService {
     }
 
     private async copyProxyScript() {
-        const [proxyScript, launcher] = await Promise.all([
-            this.copyFileToGlobalStorage('out/local-ssh/proxy.js', 'sshproxy/proxy.js'),
-            isWindows ? this.copyFileToGlobalStorage('out/local-ssh/proxylauncher.bat', 'sshproxy/proxylauncher.bat') : this.copyFileToGlobalStorage('out/local-ssh/proxylauncher.sh', 'sshproxy/proxylauncher.sh')
-        ]);
-        if (!isWindows) {
-            await fsp.chmod(launcher, 0o755);
+        try {
+            const [proxyScript, launcher] = await Promise.all([
+                this.copyFileToGlobalStorage('out/local-ssh/proxy.js', 'sshproxy/proxy.js'),
+                isWindows ? this.copyFileToGlobalStorage('out/local-ssh/proxylauncher.bat', 'sshproxy/proxylauncher.bat') : this.copyFileToGlobalStorage('out/local-ssh/proxylauncher.sh', 'sshproxy/proxylauncher.sh')
+            ]);
+            if (!isWindows) {
+                await fsp.chmod(launcher, 0o755);
+            }
+            return { proxyScript, launcher };
+        } catch (e) {
+            throw new WrapError('Failed to copy local ssh proxy scripts', e);
         }
-        return { proxyScript, launcher };
     }
 
     private async copyFileToGlobalStorage(filepath: string, destPath: string) {
diff --git a/src/ssh/sshConfig.ts b/src/ssh/sshConfig.ts
@@ -8,8 +8,9 @@ import * as fs from 'fs';
 import * as path from 'path';
 import SSHConfig, { Line, Section, Directive } from 'ssh-config';
 import * as vscode from 'vscode';
-import { exists, isFile, untildify } from '../common/files';
+import { exists, isDir, isFile, untildify } from '../common/files';
 import { isWindows } from '../common/platform';
+import { WrapError } from '../common/utils';
 
 const systemSSHConfig = isWindows ? path.resolve(process.env.ALLUSERSPROFILE || 'C:\\ProgramData', 'ssh\\ssh_config') : '/etc/ssh/ssh_config';
 const defaultSSHConfigPath = path.resolve(os.homedir(), '.ssh/config');
@@ -76,7 +77,7 @@ export default class SSHConfiguration {
 
     static async loadGitpodSSHConfig(): Promise<SSHConfiguration> {
         if (!(await isFile(gitpodSSHConfigPath))) {
-            throw new Error(`Gitpod ssh config file ${gitpodSSHConfigPath} does not exist`);
+            throw new WrapError(`Gitpod ssh config file ${gitpodSSHConfigPath} does not exist`, null, 'NotFile');
         }
 
         let content = (await fs.promises.readFile(gitpodSSHConfigPath, 'utf8')).trim();
@@ -86,13 +87,13 @@ export default class SSHConfiguration {
 
     static async saveGitpodSSHConfig(config: SSHConfiguration): Promise<void> {
         if (!(await isFile(gitpodSSHConfigPath))) {
-            throw new Error(`Gitpod ssh config file ${gitpodSSHConfigPath} does not exist`);
+            throw new WrapError(`Gitpod ssh config file ${gitpodSSHConfigPath} does not exist`, null, 'NotFile');
         }
 
         try {
             await fs.promises.writeFile(gitpodSSHConfigPath, config.toString());
         } catch (e) {
-            throw new Error(`Could not write gitpod ssh config file ${gitpodSSHConfigPath}: ${e}`);
+            throw new WrapError(`Could not write gitpod ssh config file ${gitpodSSHConfigPath}`, e);
         }
     }
 
@@ -110,7 +111,7 @@ Include "gitpod/config"
             try {
                 content = (await fs.promises.readFile(configPath, 'utf8')).trim();
             } catch (e) {
-                throw new Error(`Could not read ssh config file at ${configPath}: ${e}`);
+                throw new WrapError(`Could not read ssh config file at ${configPath}`, e);
             }
         }
 
@@ -119,37 +120,50 @@ Include "gitpod/config"
             content = `${gitpodIncludeSection}\n\n${content}`;
 
             const configFileDir = path.dirname(configPath);
+            // must be dir
             if (!(await exists(configFileDir))) {
                 try {
                     await fs.promises.mkdir(configFileDir, { recursive: true });
                 } catch (e) {
-                    throw new Error(`Could not create ssh config folder ${configFileDir}: ${e}`);
+                    throw new WrapError(`Could not create ssh config folder ${configFileDir}`, e);
                 }
             }
+            if (!(await isDir(configFileDir)))  {
+                throw new WrapError(`${configFileDir} is not a directory, cannot write ssh config file`, null, 'NotDirectory');
+            }
 
             try {
                 await fs.promises.writeFile(configPath, content);
             } catch (e) {
-                throw new Error(`Could not write ssh config file ${configPath}: ${e}`);
+                throw new WrapError(`Could not write ssh config file ${configPath}`, e);
             }
         }
 
         const gitpodConfigFileDir = path.dirname(gitpodSSHConfigPath);
+        // must be dir
         if (!(await exists(gitpodConfigFileDir))) {
             try {
                 await fs.promises.mkdir(gitpodConfigFileDir, { recursive: true });
             } catch (e) {
-                throw new Error(`Could not create gitpod ssh config folder ${gitpodConfigFileDir}: ${e}`);
+                throw new WrapError(`Could not create gitpod ssh config folder ${gitpodConfigFileDir}`, e);
             }
         }
 
+        if (!(await isDir(gitpodConfigFileDir)))  {
+            throw new WrapError(`${gitpodConfigFileDir} is not a directory, cannot write ssh config file`, null, 'NotDirectory');
+        }
+
+        // must be file
         if (!(await exists(gitpodSSHConfigPath))) {
             try {
                 await fs.promises.writeFile(gitpodSSHConfigPath, gitpodHeader);
             } catch (e) {
-                throw new Error(`Could not write gitpod ssh config file ${gitpodSSHConfigPath}: ${e}`);
+                throw new WrapError(`Could not write gitpod ssh config file ${gitpodSSHConfigPath}`, e);
             }
         }
+        if (!(await isFile(gitpodSSHConfigPath)))  {
+            throw new WrapError(`${gitpodSSHConfigPath} is not a file, cannot write ssh config file`, null, 'NotFile');
+        }
     }
 
     constructor(private sshConfig: SSHConfig) {

Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,15 @@ export async function isFile(path: string) {`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
	`29`	`+export async function isDir(path: string) {`
	`30`	`+ try {`
	`31`	`+ const s = await fs.promises.stat(path);`
	`32`	`+ return s.isDirectory();`
	`33`	`+ } catch {`
	`34`	`+ return false;`
	`35`	`+ }`
	`36`	`+}`
	`37`	`+`
`29`	`38`	`export function untildify(path: string){`
`30`	`39`	`return path.replace(/^~(?=$\|\/\|\\)/, homeDir);`
`31`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,10 +13,7 @@ function getGitpodHost() {`
`13`	`13`	`return vscode.workspace.getConfiguration('gitpod').get<string>('host', 'https://gitpod.io/');`
`14`	`14`	`}`
`15`	`15`
`16`		`-function getUseLocalApp(useLocalSSHServer?: boolean) {`
`17`		`- if (useLocalSSHServer) {`
`18`		`- return false;`
`19`		`- }`
	`16`	`+function getUseLocalApp() {`
`20`	`17`	`return vscode.workspace.getConfiguration('gitpod').get<boolean>('remote.useLocalApp', false);`
`21`	`18`	`}`
`22`	`19`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ class ExtensionServiceImpl implements ExtensionServiceImplementation {`
`112`	`112`	`};`
`113`	`113`	`} catch (e) {`
`114`	`114`	`this.logService.error(e, 'failed to get workspace auth info');`
`115`		`- throw e;`
	`115`	`+ throw new ServerError(Status.UNAVAILABLE, e.toString());`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ export class RemoteSession extends Disposable {`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`try {`
`64`		`- const useLocalSSH = await this.experiments.getUseLocalSSHProxy(this.connectionInfo.gitpodHost);`
	`64`	`+ const useLocalSSH = await this.experiments.getUseLocalSSHProxy();`
`65`	`65`	`if (useLocalSSH) {`
`66`	`66`	`this.extensionServiceServer = new ExtensionServiceServer(this.logService, this.sessionService, this.hostService, this.telemetryService, this.experiments);`
`67`	`67`	`}`