Bring telemetry inside proxy IDE-142 (#72)

* Bring telemetry inside proxy

* Add common telemetry

---------

Co-authored-by: Jean Pierre <[email protected]>

Author: mustard-mh

package.json

@@ -4,7 +4,6 @@
 	"description": "Gitpod Support",
 	"publisher": "gitpod",
 	"version": "0.0.115",
-	"daemonVersion": "0.0.9",
 	"license": "MIT",
 	"icon": "resources/gitpod.png",
 	"repository": {

src/authentication/authentication.ts

@@ -9,7 +9,7 @@ import Keychain from '../common/keychain';
 import GitpodServer from './gitpodServer';
 import { arrayEquals } from '../common/utils';
 import { Disposable } from '../common/dispose';
-import { ITelemetryService, UserFlowTelemetryProperties } from '../services/telemetryService';
+import { ITelemetryService, UserFlowTelemetryProperties } from '../common/telemetry';
 import { INotificationService } from '../services/notificationService';
 import { ILogService } from '../services/logService';
 import { Configuration } from '../configuration';

src/authentication/gitpodServer.ts

@@ -4,13 +4,13 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { PromiseAdapter, promiseFromEvent } from '../common/utils';
+import { PromiseAdapter, promiseFromEvent } from '../common/event';
 import { withServerApi } from '../internalApi';
 import pkceChallenge from 'pkce-challenge';
 import { v4 as uuid } from 'uuid';
 import { Disposable } from '../common/dispose';
 import { INotificationService } from '../services/notificationService';
-import { UserFlowTelemetryProperties } from '../services/telemetryService';
+import { UserFlowTelemetryProperties } from '../common/telemetry';
 import { ILogService } from '../services/logService';
 
 interface ExchangeTokenResponse {

src/commands/logs.ts

@@ -11,7 +11,7 @@ import * as vscode from 'vscode';
 import { Command } from '../commandManager';
 import { ILogService } from '../services/logService';
 import { INotificationService } from '../services/notificationService';
-import { ITelemetryService, UserFlowTelemetryProperties } from '../services/telemetryService';
+import { ITelemetryService, UserFlowTelemetryProperties } from '../common/telemetry';
 import { HostService } from '../services/hostService';
 
 interface IFile {

src/common/event.ts

@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Gitpod. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { EventEmitter, Event, Disposable } from 'vscode';
+
+export function filterEvent<T>(event: Event<T>, filter: (e: T) => boolean): Event<T> {
+	return (listener, thisArgs = null, disposables?) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables);
+}
+
+/**
+ * Given an event, returns another event which only fires once.
+ *
+ * @param event The event source for the new event.
+ */
+export function onceEvent<T>(event: Event<T>): Event<T> {
+	return (listener, thisArgs = null, disposables?) => {
+		// we need this, in case the event fires during the listener call
+		let didFire = false;
+		let result: Disposable | undefined = undefined;
+		result = event(e => {
+			if (didFire) {
+				return;
+			} else if (result) {
+				result.dispose();
+			} else {
+				didFire = true;
+			}
+
+			return listener.call(thisArgs, e);
+		}, null, disposables);
+
+		if (didFire) {
+			result.dispose();
+		}
+
+		return result;
+	};
+}
+
+const passthrough = (value: any, resolve: (value?: any) => void) => resolve(value);
+
+export interface PromiseAdapter<T, U> {
+	(
+		value: T,
+		resolve:
+			(value: U | PromiseLike<U>) => void,
+		reject:
+			(reason: any) => void
+	): any;
+}
+
+/**
+ * Return a promise that resolves with the next emitted event, or with some future
+ * event as decided by an adapter.
+ *
+ * If specified, the adapter is a function that will be called with
+ * `(event, resolve, reject)`. It will be called once per event until it resolves or
+ * rejects.
+ *
+ * The default adapter is the passthrough function `(value, resolve) => resolve(value)`.
+ *
+ * @param event the event
+ * @param adapter controls resolution of the returned promise
+ * @returns a promise that resolves or rejects as specified by the adapter
+ */
+export function promiseFromEvent<T, U>(
+	event: Event<T>,
+	adapter: PromiseAdapter<T, U> = passthrough): { promise: Promise<U>; cancel: EventEmitter<void> } {
+	let subscription: Disposable;
+	let cancel = new EventEmitter<void>();
+	return {
+		promise: new Promise<U>((resolve, reject) => {
+			cancel.event(_ => reject('Cancelled'));
+			subscription = event((value: T) => {
+				try {
+					Promise.resolve(adapter(value, resolve, reject))
+						.catch(reject);
+				} catch (error) {
+					reject(error);
+				}
+			});
+		}).then(
+			(result: U) => {
+				subscription.dispose();
+				return result;
+			},
+			error => {
+				subscription.dispose();
+				throw error;
+			}
+		),
+		cancel
+	};
+}
+
+export function eventToPromise<T>(event: Event<T>): Promise<T> {
+	return new Promise(resolve => onceEvent(event)(resolve));
+}