Add experimentation service to github auth extension

extensions/github-authentication/src/experimentationService.ts

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as path from 'path';
+import * as vscode from 'vscode';
+import TelemetryReporter from 'vscode-extension-telemetry';
+import { getExperimentationService, IExperimentationService, IExperimentationTelemetry, TargetPopulation } from 'vscode-tas-client';
+
+export class ExperimentationTelemetry implements IExperimentationTelemetry {
+	private sharedProperties: Record<string, string> = {};
+
+	constructor(private baseReporter: TelemetryReporter) { }
+
+	sendTelemetryEvent(eventName: string, properties?: Record<string, string>, measurements?: Record<string, number>) {
+		this.baseReporter.sendTelemetryEvent(
+			eventName,
+			{
+				...this.sharedProperties,
+				...properties,
+			},
+			measurements,
+		);
+	}
+
+	sendTelemetryErrorEvent(
+		eventName: string,
+		properties?: Record<string, string>,
+		_measurements?: Record<string, number>,
+	) {
+		this.baseReporter.sendTelemetryErrorEvent(eventName, {
+			...this.sharedProperties,
+			...properties,
+		});
+	}
+
+	setSharedProperty(name: string, value: string): void {
+		this.sharedProperties[name] = value;
+	}
+
+	postEvent(eventName: string, props: Map<string, string>): void {
+		const event: Record<string, string> = {};
+		for (const [key, value] of props) {
+			event[key] = value;
+		}
+		this.sendTelemetryEvent(eventName, event);
+	}
+
+	dispose(): Promise<any> {
+		return this.baseReporter.dispose();
+	}
+}
+
+interface ProductConfiguration {
+	quality?: 'stable' | 'insider' | 'exploration';
+}
+
+async function getProductConfig(appRoot: string): Promise<ProductConfiguration> {
+	const raw = await vscode.workspace.fs.readFile(vscode.Uri.file(path.join(appRoot, 'product.json')));
+	return JSON.parse(raw.toString());
+}
+
+function getTargetPopulation(product: ProductConfiguration): TargetPopulation {
+	switch (product.quality) {
+		case 'stable':
+			return TargetPopulation.Public;
+		case 'insider':
+			return TargetPopulation.Insiders;
+		case 'exploration':
+			return TargetPopulation.Internal;
+		case undefined:
+			return TargetPopulation.Team;
+		default:
+			return TargetPopulation.Public;
+	}
+}
+
+export async function createExperimentationService(context: vscode.ExtensionContext, telemetry: ExperimentationTelemetry): Promise<IExperimentationService> {
+	const id = context.extension.id;
+	const version = context.extension.packageJSON.version;
+	const product = await getProductConfig(vscode.env.appRoot);
+	const targetPopulation = getTargetPopulation(product);
+	return getExperimentationService(id, version, targetPopulation, telemetry, context.globalState);
+}

extensions/github-authentication/src/extension.ts

@@ -8,10 +8,14 @@ import { GitHubAuthenticationProvider, onDidChangeSessions } from './github';
 import { uriHandler } from './githubServer';
 import Logger from './common/logger';
 import TelemetryReporter from 'vscode-extension-telemetry';
+import { createExperimentationService, ExperimentationTelemetry } from './experimentationService';
 
 export async function activate(context: vscode.ExtensionContext) {
 	const { name, version, aiKey } = require('../package.json') as { name: string, version: string, aiKey: string };
-	const telemetryReporter = new TelemetryReporter(name, version, aiKey);
+	const telemetryReporter = new ExperimentationTelemetry(new TelemetryReporter(name, version, aiKey));
+
+	const experimentationService = await createExperimentationService(context, telemetryReporter);
+	await experimentationService.initialFetch;
 
 	context.subscriptions.push(vscode.window.registerUriHandler(uriHandler));
 	const loginService = new GitHubAuthenticationProvider(context, telemetryReporter);

extensions/github-authentication/src/github.ts

@@ -9,7 +9,7 @@ import { Keychain } from './common/keychain';
 import { GitHubServer, NETWORK_ERROR } from './githubServer';
 import Logger from './common/logger';
 import { arrayEquals } from './common/utils';
-import TelemetryReporter from 'vscode-extension-telemetry';
+import { ExperimentationTelemetry } from './experimentationService';
 
 export const onDidChangeSessions = new vscode.EventEmitter<vscode.AuthenticationProviderAuthenticationSessionsChangeEvent>();
 
@@ -30,7 +30,7 @@ export class GitHubAuthenticationProvider {
 
 	private _keychain: Keychain;
 
-	constructor(context: vscode.ExtensionContext, telemetryReporter: TelemetryReporter) {
+	constructor(context: vscode.ExtensionContext, telemetryReporter: ExperimentationTelemetry) {
 		this._keychain = new Keychain(context);
 		this._githubServer = new GitHubServer(telemetryReporter);
 	}

extensions/github-authentication/src/githubServer.ts

@@ -9,7 +9,7 @@ import fetch, { Response } from 'node-fetch';
 import { v4 as uuid } from 'uuid';
 import { PromiseAdapter, promiseFromEvent } from './common/utils';
 import Logger from './common/logger';
-import TelemetryReporter from 'vscode-extension-telemetry';
+import { ExperimentationTelemetry } from './experimentationService';
 
 const localize = nls.loadMessageBundle();
 
@@ -42,7 +42,7 @@ export class GitHubServer {
 	private _pendingStates = new Map<string, string[]>();
 	private _codeExchangePromises = new Map<string, { promise: Promise<string>, cancel: vscode.EventEmitter<void> }>();
 
-	constructor(private readonly telemetryReporter: TelemetryReporter) { }
+	constructor(private readonly telemetryReporter: ExperimentationTelemetry) { }
 
 	private isTestEnvironment(url: vscode.Uri): boolean {
 		return /\.azurewebsites\.net$/.test(url.authority) || url.authority.startsWith('localhost:');