report telemetry to corresponding host

Author: akosyakov

.github/workflows/nightly.yml

@@ -22,7 +22,7 @@ jobs:
       - name: Update package.json
         run: |
           set -e
-          setSegmentKey="setpath([\"segmentKey\"]; \"${{ secrets.ANALITYCS_KEY }}\")"
+          setSegmentKey="setpath([\"segmentKey\"]; \"untrusted-dummy-key\")"
           setConfigcatKey="setpath([\"configcatKey\"]; \"${{ secrets.CONFIGCAT_KEY }}\")"
           jqCommands="${setSegmentKey} | ${setConfigcatKey}"
           cat package.json | jq "${jqCommands}" > package.json.tmp

.github/workflows/release.yml

@@ -19,7 +19,7 @@ jobs:
       - name: Update Segment
         run: |
           set -e
-          setSegmentKey="setpath([\"segmentKey\"]; \"${{ secrets.ANALITYCS_KEY }}\")"
+          setSegmentKey="setpath([\"segmentKey\"]; \"untrusted-dummy-key\")"
           setConfigcatKey="setpath([\"configcatKey\"]; \"${{ secrets.CONFIGCAT_KEY }}\")"
           jqCommands="${setSegmentKey} | ${setConfigcatKey}"
           cat package.json | jq "${jqCommands}" > package.json.tmp

src/authentication/authentication.ts

@@ -34,7 +34,7 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 
 	private _sessionsPromise: Promise<vscode.AuthenticationSession[]>;
 
-	private readonly flow: Readonly<UserFlowTelemetry> = { flow: 'auth' };
+	private readonly flow = { flow: 'auth' } as Readonly<UserFlowTelemetry>;
 
 	constructor(
 		private readonly context: vscode.ExtensionContext,

src/commands/logs.ts

@@ -13,6 +13,7 @@ import { ILogService } from '../services/logService';
 import { INotificationService } from '../services/notificationService';
 import { ITelemetryService, UserFlowTelemetry } from '../services/telemetryService';
 import { Configuration } from '../configuration';
+import { HostService } from '../services/hostService';
 
 interface IFile {
 	path: string;
@@ -27,10 +28,12 @@ export class ExportLogsCommand implements Command {
 		private readonly notificationService: INotificationService,
 		private readonly telemetryService: ITelemetryService,
 		private readonly logService: ILogService,
+		private readonly hostService: HostService,
 	) { }
 
 	async execute() {
-		const flow: UserFlowTelemetry = { flow: 'export_logs' };
+		const gitpodHost = this.hostService.gitpodHost;
+		const flow: UserFlowTelemetry = { gitpodHost, flow: 'export_logs' };
 		this.telemetryService.sendUserFlowStatus('exporting', flow);
 		try {
 			await this.exportLogs();

src/common/telemetry.ts

@@ -63,12 +63,10 @@ export class BaseTelemetryAppender implements ITelemetryAppender {
 	private _exceptionQueue: Array<{ exception: Error; data: AppenderData | undefined }> = [];
 
 	// Necessary information to create a telemetry client
-	private _clientFactory: (key: string) => Promise<BaseTelemetryClient>;
-	private _key: string;
+	private _clientFactory: () => Promise<BaseTelemetryClient>;
 
-	constructor(key: string, clientFactory: (key: string) => Promise<BaseTelemetryClient>) {
+	constructor(clientFactory: () => Promise<BaseTelemetryClient>) {
 		this._clientFactory = clientFactory;
-		this._key = key;
 		if (getTelemetryLevel() !== TelemetryLevel.OFF) {
 			this.instantiateAppender();
 		}
@@ -124,20 +122,25 @@ export class BaseTelemetryAppender implements ITelemetryAppender {
 		this._exceptionQueue = [];
 	}
 
+	private isInstantiating = false;
+
 	/**
 	 * Instantiates the telemetry client to make the appender "active"
 	 */
 	instantiateAppender(): void {
-		if (this._isInstantiated) {
+		if (this.isInstantiating || this._isInstantiated) {
 			return;
 		}
+		this.isInstantiating = true;
 		// Call the client factory to get the client and then let it know it's instatntiated
-		this._clientFactory(this._key).then(client => {
+		this._clientFactory().then(client => {
 			this._telemetryClient = client;
 			this._isInstantiated = true;
 			this._flushQueues();
 		}).catch(err => {
 			console.error(err);
+		}).finally(() => {
+			this.isInstantiating = false;
 		});
 	}
 }
@@ -146,12 +149,13 @@ export class BaseTelemetryReporter extends Disposable {
 	private userOptIn = false;
 	private errorOptIn = false;
 	private _extension: vscode.Extension<any> | undefined;
+	private readonly appenders = new Map<string, ITelemetryAppender>();
 
 	constructor(
 		private extensionId: string,
 		private extensionVersion: string,
-		private telemetryAppender: ITelemetryAppender,
 		private osShim: { release: string; platform: string; architecture: string },
+		private readonly clientFactory: (gitpodHost: string) => Promise<BaseTelemetryClient>
 	) {
 		super();
 
@@ -173,7 +177,7 @@ export class BaseTelemetryReporter extends Disposable {
 		this.userOptIn = telemetryLevel === TelemetryLevel.ON;
 		this.errorOptIn = telemetryLevel === TelemetryLevel.ERROR || this.userOptIn;
 		if (this.userOptIn || this.errorOptIn) {
-			this.telemetryAppender.instantiateAppender();
+			this.appenders.forEach(appender => appender.instantiateAppender());
 		}
 	}
 
@@ -354,11 +358,11 @@ export class BaseTelemetryReporter extends Disposable {
 	 * @param eventName The name of the event
 	 * @param properties The properties to send with the event
 	 */
-	public sendTelemetryEvent(eventName: string, properties?: TelemetryEventProperties): void {
+	public sendTelemetryEvent(gitpodHost: string, eventName: string, properties?: TelemetryEventProperties): void {
 		if (this.userOptIn && eventName !== '') {
 			properties = { ...properties, ...this.getCommonProperties() };
 			const cleanProperties = this.cloneAndChange(properties, (_key: string, prop: string) => this.anonymizeFilePaths(prop, false));
-			this.telemetryAppender.logEvent(`${eventName}`, { properties: this.removePropertiesWithPossibleUserInfo(cleanProperties) });
+			this.getAppender(gitpodHost).logEvent(`${eventName}`, { properties: this.removePropertiesWithPossibleUserInfo(cleanProperties) });
 		}
 	}
 
@@ -367,10 +371,10 @@ export class BaseTelemetryReporter extends Disposable {
 	 * @param eventName The name of the event
 	 * @param properties The properties to send with the event
 	 */
-	public sendRawTelemetryEvent(eventName: string, properties?: RawTelemetryEventProperties): void {
+	public sendRawTelemetryEvent(gitpodHost: string, eventName: string, properties?: RawTelemetryEventProperties): void {
 		if (this.userOptIn && eventName !== '') {
 			properties = { ...properties, ...this.getCommonProperties() };
-			this.telemetryAppender.logEvent(`${eventName}`, { properties });
+			this.getAppender(gitpodHost).logEvent(`${eventName}`, { properties });
 		}
 	}
 
@@ -379,14 +383,14 @@ export class BaseTelemetryReporter extends Disposable {
 	 * @param eventName The name of the event
 	 * @param properties The properties to send with the event
 	 */
-	public sendTelemetryErrorEvent(eventName: string, properties?: { [key: string]: string }): void {
+	public sendTelemetryErrorEvent(gitpodHost: string, eventName: string, properties?: { [key: string]: string }): void {
 		if (this.errorOptIn && eventName !== '') {
 			// always clean the properties if first party
 			// do not send any error properties if we shouldn't send error telemetry
 			// if we have no errorProps, assume all are error props
 			properties = { ...properties, ...this.getCommonProperties() };
 			const cleanProperties = this.cloneAndChange(properties, (_key: string, prop: string) => this.anonymizeFilePaths(prop, false));
-			this.telemetryAppender.logEvent(`${eventName}`, { properties: this.removePropertiesWithPossibleUserInfo(cleanProperties) });
+			this.getAppender(gitpodHost).logEvent(`${eventName}`, { properties: this.removePropertiesWithPossibleUserInfo(cleanProperties) });
 		}
 	}
 
@@ -395,20 +399,31 @@ export class BaseTelemetryReporter extends Disposable {
 	 * @param error The error to send
 	 * @param properties The properties to send with the event
 	 */
-	public sendTelemetryException(error: Error, properties?: TelemetryEventProperties): void {
+	public sendTelemetryException(gitpodHost: string, error: Error, properties?: TelemetryEventProperties): void {
 		if (this.errorOptIn && error) {
 			properties = { ...properties, ...this.getCommonProperties() };
 			const cleanProperties = this.cloneAndChange(properties, (_key: string, prop: string) => this.anonymizeFilePaths(prop, false));
 			// Also run the error stack through the anonymizer
 			if (error.stack) {
 				error.stack = this.anonymizeFilePaths(error.stack, false);
 			}
-			this.telemetryAppender.logException(error, { properties: this.removePropertiesWithPossibleUserInfo(cleanProperties) });
+			this.getAppender(gitpodHost).logException(error, { properties: this.removePropertiesWithPossibleUserInfo(cleanProperties) });
+		}
+	}
+
+	private getAppender(gitpodHost: string) {
+		const gitpodHostUrl = new URL(gitpodHost);
+		const serviceUrl = gitpodHostUrl.toString().replace(/\/$/, '').toLowerCase();
+		let appender = this.appenders.get(serviceUrl);
+		if (!appender) {
+			appender = new BaseTelemetryAppender(() => this.clientFactory(serviceUrl));
+			this.appenders.set(serviceUrl, appender);
 		}
+		return appender;
 	}
 
 	public override async dispose(): Promise<void> {
 		super.dispose();
-		await this.telemetryAppender.flush();
+		await Promise.allSettled([...this.appenders.values()].map(a => a.flush()));
 	}
 }

src/daemonStarter.ts

@@ -28,7 +28,11 @@ export async function ensureDaemonStarted(logService: ILogService, telemetryServ
             }
             logService.error('lssh unexpectedly exit with code: ' + code + ' attempt retry: ' + retry);
             resolve(false);
-            telemetryService.sendTelemetryException(new Error(`unexpectedly exit with code ${humanReadableCode} ${code} attempt retry: ${retry}`), { humanReadableCode, code: code?.toString() ?? 'null' });
+            telemetryService.sendTelemetryException(
+                Configuration.getGitpodHost(),
+                new Error(`unexpectedly exit with code ${humanReadableCode} ${code} attempt retry: ${retry}`),
+                { humanReadableCode, code: code?.toString() ?? 'null' }
+            );
         });
     });
     if (!ok) {

src/extension.ts

@@ -23,6 +23,7 @@ import { SignInCommand } from './commands/account';
 import { ExportLogsCommand } from './commands/logs';
 import { ensureDaemonStarted } from './daemonStarter';
 import { ExtensionServiceServer } from './local-ssh/ipc/extension';
+import { Configuration } from './configuration';
 
 // connect-web uses fetch api, so we need to polyfill it
 if (!global.fetch) {
@@ -39,6 +40,7 @@ const FIRST_INSTALL_KEY = 'gitpod-desktop.firstInstall';
 let telemetryService: TelemetryService | undefined;
 let remoteSession: RemoteSession | undefined;
 let logger: vscode.LogOutputChannel | undefined;
+let hostService: HostService | undefined;
 
 export async function activate(context: vscode.ExtensionContext) {
 	const extensionId = context.extension.id;
@@ -61,7 +63,7 @@ export async function activate(context: vscode.ExtensionContext) {
 
 		logger.info(`${extensionId}/${packageJSON.version} (${os.release()} ${os.platform()} ${os.arch()}) vscode/${vscode.version} (${vscode.env.appName})`);
 
-		telemetryService = new TelemetryService(extensionId, packageJSON.version, packageJSON.segmentKey, logger!, context.extensionMode === vscode.ExtensionMode.Production);
+		telemetryService = new TelemetryService(extensionId, packageJSON.version, packageJSON.segmentKey, logger!);
 
 		const notificationService = new NotificationService(telemetryService);
 
@@ -72,7 +74,7 @@ export async function activate(context: vscode.ExtensionContext) {
 		const authProvider = new GitpodAuthenticationProvider(context, logger, telemetryService, notificationService);
 		context.subscriptions.push(authProvider);
 
-		const hostService = new HostService(context, notificationService, logger);
+		hostService = new HostService(context, notificationService, logger);
 		context.subscriptions.push(hostService);
 
 		const sessionService = new SessionService(hostService, logger);
@@ -105,13 +107,13 @@ export async function activate(context: vscode.ExtensionContext) {
 
 		// Register global commands
 		commandManager.register(new SignInCommand(sessionService));
-		commandManager.register(new ExportLogsCommand(context.logUri, notificationService, telemetryService, logger));
+		commandManager.register(new ExportLogsCommand(context.logUri, notificationService, telemetryService, logger, hostService));
 
 		ensureDaemonStarted(logger, telemetryService, 3).then(() => { }).catch(e => { logger?.error(e) });
 
 		if (!context.globalState.get<boolean>(FIRST_INSTALL_KEY, false)) {
 			context.globalState.update(FIRST_INSTALL_KEY, true);
-			telemetryService.sendTelemetryEvent('gitpod_desktop_installation', { kind: 'install' });
+			telemetryService.sendTelemetryEvent(hostService.gitpodHost, 'gitpod_desktop_installation', { kind: 'install' });
 		}
 
 		remoteConnectionInfo = getGitpodRemoteWindowConnectionInfo(context);
@@ -120,17 +122,17 @@ export async function activate(context: vscode.ExtensionContext) {
 			if (remoteConnectionInfo) {
 				commandManager.register({ id: 'gitpod.api.autoTunnel', execute: () => remoteConnector.autoTunnelCommand });
 
-				remoteSession = new RemoteSession(remoteConnectionInfo.remoteAuthority, remoteConnectionInfo.connectionInfo, context, hostService, sessionService, settingsSync, experiments, logger!, telemetryService!, notificationService);
+				remoteSession = new RemoteSession(remoteConnectionInfo.remoteAuthority, remoteConnectionInfo.connectionInfo, context, hostService!, sessionService, settingsSync, experiments, logger!, telemetryService!, notificationService);
 				await remoteSession.initialize();
 			} else if (sessionService.isSignedIn()) {
-				const restartFlow = { flow: 'restart_workspace', userId: sessionService.getUserId() };
-				checkForStoppedWorkspaces(context, hostService.gitpodHost, restartFlow, notificationService, logger!);
+				const restartFlow = { flow: 'restart_workspace', userId: sessionService.getUserId(), gitpodHost: hostService!.gitpodHost };
+				checkForStoppedWorkspaces(context, restartFlow, notificationService, logger!);
 			}
 		});
 
 		success = true;
 	} catch (e) {
-		telemetryService?.sendTelemetryException(e);
+		telemetryService?.sendTelemetryException(hostService?.gitpodHost || Configuration.getGitpodHost(), e);
 		throw e;
 	} finally {
 		const rawActivateProperties = {
@@ -142,8 +144,9 @@ export async function activate(context: vscode.ExtensionContext) {
 			debugWorkspace: remoteConnectionInfo ? String(!!remoteConnectionInfo.connectionInfo.debugWorkspace) : '',
 			success: String(success)
 		};
+		const gitpodHost = rawActivateProperties.gitpodHost || hostService?.gitpodHost || Configuration.getGitpodHost();
 		logger?.info('Activation properties:', JSON.stringify(rawActivateProperties, undefined, 2));
-		telemetryService?.sendTelemetryEvent('vscode_desktop_activate', {
+		telemetryService?.sendTelemetryEvent(gitpodHost, 'vscode_desktop_activate', {
 			...rawActivateProperties,
 			remoteUri: String(!!rawActivateProperties.remoteUri)
 		});

src/heartbeat.ts

@@ -131,7 +131,7 @@ export class HeartbeatManager extends Disposable {
                         ? (!wasClosed ? await this.sessionService.getAPI().sendHeartbeat(this.connectionInfo.workspaceId) : await this.sessionService.getAPI().sendDidClose(this.connectionInfo.workspaceId))
                         : await service.server.sendHeartBeat({ instanceId: this.connectionInfo.instanceId, wasClosed });
                     if (wasClosed) {
-                        this.telemetryService.sendTelemetryEvent('ide_close_signal', { workspaceId: this.connectionInfo.workspaceId, instanceId: this.connectionInfo.instanceId, gitpodHost: this.connectionInfo.gitpodHost, clientKind: 'vscode', debugWorkspace: String(!!this.connectionInfo.debugWorkspace) });
+                        this.telemetryService.sendTelemetryEvent(this.connectionInfo.gitpodHost, 'ide_close_signal', { workspaceId: this.connectionInfo.workspaceId, instanceId: this.connectionInfo.instanceId, gitpodHost: this.connectionInfo.gitpodHost, clientKind: 'vscode', debugWorkspace: String(!!this.connectionInfo.debugWorkspace) });
                         this.logService.trace(`Send closed heartbeat`);
                     } else {
                         this.logService.trace(`Send heartbeat, triggered by ${this.lastActivityEvent} event`);
@@ -147,7 +147,7 @@ export class HeartbeatManager extends Disposable {
             e.message = `Failed to send ${suffix}, triggered by event: ${this.lastActivityEvent}: ${originMsg}`;
             this.logService.error(e);
             e.message = `Failed to send ${suffix}: ${originMsg}`;
-            this.telemetryService.sendTelemetryException(e, { workspaceId: this.connectionInfo.workspaceId, instanceId: this.connectionInfo.instanceId});
+            this.telemetryService.sendTelemetryException(this.connectionInfo.gitpodHost, e, { workspaceId: this.connectionInfo.workspaceId, instanceId: this.connectionInfo.instanceId});
         }
     }
 
@@ -159,7 +159,7 @@ export class HeartbeatManager extends Disposable {
     }
 
     private sendEventData() {
-        this.telemetryService.sendRawTelemetryEvent('vscode_desktop_heartbeat_delta', { events: Object.fromEntries(this.eventCounterMap), workspaceId: this.connectionInfo.workspaceId, instanceId: this.connectionInfo.instanceId, gitpodHost: this.connectionInfo.gitpodHost, clientKind: 'vscode' });
+        this.telemetryService.sendRawTelemetryEvent(this.connectionInfo.gitpodHost, 'vscode_desktop_heartbeat_delta', { events: Object.fromEntries(this.eventCounterMap), workspaceId: this.connectionInfo.workspaceId, instanceId: this.connectionInfo.instanceId, gitpodHost: this.connectionInfo.gitpodHost, clientKind: 'vscode' });
         this.eventCounterMap.clear();
     }