Import Wizard (#2130)

Flat File Importer

extensions/import/src/services/config.json

@@ -0,0 +1,16 @@
+{
+    "downloadUrl": "https://sqlopsextensions.blob.core.windows.net/extensions/import/{#fileName#}",
+    "useDefaultLinuxRuntime": true,
+    "version": "0.0.1",
+    "downloadFileNames": {
+        "Windows_64": "win-x64.zip",
+        "Windows_86": "win-x86.zip",
+        "OSX": "osx.zip",
+        "Linux_64": "linux-x64.tar.gz"
+    },
+    "installDirectory": "flatfileimportservice/{#platform#}/{#version#}",
+    "executableFiles": [
+        "MicrosoftSqlToolsFlatFileImport",
+        "MicrosoftSqlToolsFlatFileImport.exe"
+    ]
+}

extensions/import/src/services/contracts.ts

@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { RequestType, NotificationType } from 'vscode-languageclient';
+
+/**
+ * @interface IMessage
+ */
+export interface IMessage {
+	jsonrpc: string;
+}
+
+// ------------------------------- < Telemetry Sent Event > ------------------------------------
+
+/**
+ * Event sent when the language service send a telemetry event
+ */
+export namespace TelemetryNotification {
+	export const type = new NotificationType<TelemetryParams, void>('telemetry/sqlevent');
+}
+
+/**
+ * Update event parameters
+ */
+export class TelemetryParams {
+	public params: {
+		eventName: string;
+		properties: ITelemetryEventProperties;
+		measures: ITelemetryEventMeasures;
+	};
+}
+
+export interface ITelemetryEventProperties {
+	[key: string]: string;
+}
+
+export interface ITelemetryEventMeasures {
+	[key: string]: number;
+}
+
+/**
+ * Contract Classes
+ */
+export interface Result {
+	success: boolean;
+	errorMessage: string;
+}
+
+export interface ColumnInfo {
+	name: string;
+	sqlType: string;
+	isNullable: boolean;
+}
+
+
+/**
+ * PROSEDiscoveryRequest
+ * Send this request to create a new PROSE session with a new file and preview it
+ */
+const proseDiscoveryRequestName = 'flatfile/proseDiscovery';
+
+export interface PROSEDiscoveryParams {
+	filePath: string;
+	tableName: string;
+	schemaName?: string;
+	fileType?: string;
+}
+
+export interface PROSEDiscoveryResponse {
+	dataPreview: string[][];
+	columnInfo: ColumnInfo[];
+}
+
+/**
+ * InsertDataRequest
+ */
+const insertDataRequestName = 'flatfile/insertData';
+
+export interface InsertDataParams {
+	connectionString: string;
+	batchSize: number;
+}
+
+export interface InsertDataResponse {
+	result: Result;
+}
+
+
+/**
+ * GetColumnInfoRequest
+ */
+const getColumnInfoRequestName = 'flatfile/getColumnInfo';
+
+export interface GetColumnInfoParams {
+}
+
+export interface GetColumnInfoResponse {
+	columnInfo: ColumnInfo[];
+}
+
+
+/**
+ * ChangeColumnSettingsRequest
+ */
+const changeColumnSettingsRequestName = 'flatfile/changeColumnSettings';
+
+export interface ChangeColumnSettingsParams {
+	index: number;
+	newName?: string;
+	newDataType?: string;
+	newNullable?: boolean;
+	newInPrimaryKey?: boolean;
+}
+
+export interface ChangeColumnSettingsResponse {
+	result: Result;
+}
+
+/**
+ * Requests
+ */
+export namespace PROSEDiscoveryRequest {
+	export const type = new RequestType<PROSEDiscoveryParams, PROSEDiscoveryResponse, void, void>(proseDiscoveryRequestName);
+}
+
+export namespace InsertDataRequest {
+	export const type = new RequestType<InsertDataParams, InsertDataResponse, void, void>(insertDataRequestName);
+}
+
+export namespace GetColumnInfoRequest {
+	export const type = new RequestType<GetColumnInfoParams, GetColumnInfoResponse, void, void>(getColumnInfoRequestName);
+}
+
+export namespace ChangeColumnSettingsRequest {
+	export const type = new RequestType<ChangeColumnSettingsParams, ChangeColumnSettingsResponse, void, void>(changeColumnSettingsRequestName);
+}
+
+
+export interface FlatFileProvider {
+	providerId?: string;
+
+	sendPROSEDiscoveryRequest(params: PROSEDiscoveryParams): Thenable<PROSEDiscoveryResponse>;
+	sendInsertDataRequest(params: InsertDataParams): Thenable<InsertDataResponse>;
+	sendGetColumnInfoRequest(params: GetColumnInfoParams): Thenable<GetColumnInfoResponse>;
+	sendChangeColumnSettingsRequest(params: ChangeColumnSettingsParams): Thenable<ChangeColumnSettingsResponse>;
+}

extensions/import/src/services/features.ts

@@ -0,0 +1,96 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { SqlOpsDataClient, SqlOpsFeature } from 'dataprotocol-client';
+import {
+	ClientCapabilities,
+	StaticFeature,
+	RPCMessageType,
+	ServerCapabilities
+} from 'vscode-languageclient';
+import * as UUID from 'vscode-languageclient/lib/utils/uuid';
+import { Disposable } from 'vscode';
+
+import { Telemetry } from './telemetry';
+import * as serviceUtils from './serviceUtils';
+import * as Contracts from './contracts';
+import { managerInstance, ApiType } from './serviceApiManager';
+
+export class TelemetryFeature implements StaticFeature {
+
+	constructor(private _client: SqlOpsDataClient) {
+	}
+
+	fillClientCapabilities(capabilities: ClientCapabilities): void {
+		serviceUtils.ensure(capabilities, 'telemetry')!.telemetry = true;
+	}
+
+	initialize(): void {
+		this._client.onNotification(Contracts.TelemetryNotification.type, e => {
+			Telemetry.sendTelemetryEvent(e.params.eventName, e.params.properties, e.params.measures);
+		});
+	}
+}
+
+export class FlatFileImportFeature extends SqlOpsFeature<undefined> {
+	private static readonly messagesTypes: RPCMessageType[] = [
+		Contracts.PROSEDiscoveryRequest.type
+	];
+
+	constructor(client: SqlOpsDataClient) {
+		super(client, FlatFileImportFeature.messagesTypes);
+	}
+
+	public fillClientCapabilities(capabilities: ClientCapabilities): void {
+	}
+
+	public initialize(capabilities: ServerCapabilities): void {
+		this.register(this.messages, {
+			id: UUID.generateUuid(),
+			registerOptions: undefined
+		});
+	}
+
+	protected registerProvider(options: undefined): Disposable {
+		const client = this._client;
+
+		let requestSender = (requestType, params) => {
+			return client.sendRequest(requestType, params).then(
+				r => {
+					return r as any;
+				},
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.reject(e);
+				}
+			);
+		};
+
+		let sendPROSEDiscoveryRequest = (params: Contracts.PROSEDiscoveryParams): Thenable<Contracts.PROSEDiscoveryResponse> => {
+			return requestSender(Contracts.PROSEDiscoveryRequest.type, params);
+		};
+
+		let sendInsertDataRequest = (params: Contracts.InsertDataParams): Thenable<Contracts.InsertDataResponse> => {
+			return requestSender(Contracts.InsertDataRequest.type, params);
+		};
+
+		let sendGetColumnInfoRequest = (params: Contracts.GetColumnInfoParams): Thenable<Contracts.GetColumnInfoResponse> => {
+			return requestSender(Contracts.GetColumnInfoRequest.type, params);
+		};
+
+		let sendChangeColumnSettingsRequest = (params: Contracts.ChangeColumnSettingsParams): Thenable<Contracts.ChangeColumnSettingsResponse> => {
+			return requestSender(Contracts.ChangeColumnSettingsRequest.type, params);
+		};
+
+		return managerInstance.registerApi<Contracts.FlatFileProvider>(ApiType.FlatFileProvider, {
+			providerId: client.providerId,
+			sendPROSEDiscoveryRequest,
+			sendChangeColumnSettingsRequest,
+			sendGetColumnInfoRequest,
+			sendInsertDataRequest
+		});
+	}
+}

extensions/import/src/services/serviceApiManager.ts

@@ -0,0 +1,64 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as sqlops from 'sqlops';
+import * as vscode from 'vscode';
+import * as contracts from './contracts';
+import { SqlOpsDataClient } from 'dataprotocol-client/lib/main';
+
+export enum ApiType {
+	FlatFileProvider = 'FlatFileProvider'
+}
+
+export interface IServiceApi {
+	onRegisteredApi<T>(type: ApiType): vscode.Event<T>;
+	registerApi<T>(type: ApiType, feature: T): vscode.Disposable;
+}
+
+export interface IModelViewDefinition {
+	id: string;
+	modelView: sqlops.ModelView;
+}
+
+export class ServiceApiManager implements IServiceApi {
+	private modelViewRegistrations: { [id: string]: boolean } = {};
+	private featureEventChannels: { [type: string]: vscode.EventEmitter<any> } = {};
+	private _onRegisteredModelView = new vscode.EventEmitter<IModelViewDefinition>();
+
+	public onRegisteredApi<T>(type: ApiType): vscode.Event<T> {
+		let featureEmitter = this.featureEventChannels[type];
+		if (!featureEmitter) {
+			featureEmitter = new vscode.EventEmitter<T>();
+			this.featureEventChannels[type] = featureEmitter;
+		}
+		return featureEmitter.event;
+	}
+
+	public registerApi<T>(type: ApiType, feature: T): vscode.Disposable {
+		let featureEmitter = this.featureEventChannels[type];
+		if (featureEmitter) {
+			featureEmitter.fire(feature);
+		}
+		// TODO handle unregistering API on close
+		return {
+			dispose: () => undefined
+		};
+	}
+
+	public get onRegisteredModelView(): vscode.Event<IModelViewDefinition> {
+		return this._onRegisteredModelView.event;
+	}
+
+	public registerModelView(id: string, modelView: sqlops.ModelView): void {
+		this._onRegisteredModelView.fire({
+			id: id,
+			modelView: modelView
+		});
+	}
+}
+
+export let managerInstance = new ServiceApiManager();

extensions/import/src/services/serviceClient.ts

@@ -0,0 +1,165 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { SqlOpsDataClient, ClientOptions } from 'dataprotocol-client';
+import { IConfig, ServerProvider, Events } from 'service-downloader';
+import { ServerOptions, TransportKind } from 'vscode-languageclient';
+import * as vscode from 'vscode';
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+import * as path from 'path';
+import { EventAndListener } from 'eventemitter2';
+
+import { Telemetry, LanguageClientErrorHandler } from './telemetry';
+import * as Constants from '../constants';
+import { TelemetryFeature, FlatFileImportFeature } from './features';
+import * as serviceUtils from './serviceUtils';
+
+const baseConfig = require('./config.json');
+
+export class ServiceClient {
+	private statusView: vscode.StatusBarItem;
+
+	constructor(private outputChannel: vscode.OutputChannel) {
+		this.statusView = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
+	}
+
+	public startService(context: vscode.ExtensionContext): Promise<SqlOpsDataClient> {
+		let config: IConfig = JSON.parse(JSON.stringify(baseConfig));
+		config.installDirectory = path.join(context.extensionPath, config.installDirectory);
+		config.proxy = vscode.workspace.getConfiguration('http').get('proxy');
+		config.strictSSL = vscode.workspace.getConfiguration('http').get('proxyStrictSSL') || true;
+
+		const serverdownloader = new ServerProvider(config);
+		serverdownloader.eventEmitter.onAny(this.generateHandleServerProviderEvent());
+
+		let clientOptions: ClientOptions = this.createClientOptions();
+
+		const installationStart = Date.now();
+		let client: SqlOpsDataClient;
+		return new Promise((resolve, reject) => {
+			serverdownloader.getOrDownloadServer().then(e => {
+				const installationComplete = Date.now();
+				let serverOptions = this.generateServerOptions(e);
+				client = new SqlOpsDataClient(Constants.serviceName, serverOptions, clientOptions);
+				const processStart = Date.now();
+				client.onReady().then(() => {
+					const processEnd = Date.now();
+					this.statusView.text = localize('serviceStarted', 'Service Started');
+					setTimeout(() => {
+						this.statusView.hide();
+					}, 1500);
+					Telemetry.sendTelemetryEvent('startup/LanguageClientStarted', {
+						installationTime: String(installationComplete - installationStart),
+						processStartupTime: String(processEnd - processStart),
+						totalTime: String(processEnd - installationStart),
+						beginningTimestamp: String(installationStart)
+					});
+				});
+				this.statusView.show();
+				this.statusView.text = localize('serviceStarting', 'Starting service');
+				let disposable = client.start();
+				context.subscriptions.push(disposable);
+				resolve(client);
+			}, e => {
+				Telemetry.sendTelemetryEvent('ServiceInitializingFailed');
+				vscode.window.showErrorMessage(localize('serviceStartFailed', 'Failed to start Scale Out Data service:{0}', e));
+				// Just resolve to avoid unhandled promise. We show the error to the user.
+				resolve(undefined);
+			});
+		});
+	}
+
+	private createClientOptions(): ClientOptions {
+		return {
+			providerId: Constants.providerId,
+			errorHandler: new LanguageClientErrorHandler(),
+			synchronize: {
+				configurationSection: [Constants.extensionConfigSectionName, Constants.sqlConfigSectionName]
+			},
+			features: [
+				// we only want to add new features
+				TelemetryFeature,
+				FlatFileImportFeature
+			],
+			outputChannel: new CustomOutputChannel()
+		};
+	}
+
+	private generateServerOptions(executablePath: string): ServerOptions {
+		let launchArgs = [];
+		launchArgs.push('--log-dir');
+		let logFileLocation = path.join(serviceUtils.getDefaultLogLocation(), 'flatfileimport');
+		launchArgs.push(logFileLocation);
+		let config = vscode.workspace.getConfiguration(Constants.extensionConfigSectionName);
+		if (config) {
+			let logDebugInfo = config[Constants.configLogDebugInfo];
+			if (logDebugInfo) {
+				launchArgs.push('--enable-logging');
+			}
+		}
+
+		return { command: executablePath, args: launchArgs, transport: TransportKind.stdio };
+	}
+
+	private generateHandleServerProviderEvent(): EventAndListener {
+		let dots = 0;
+		return (e: string, ...args: any[]) => {
+			this.outputChannel.show();
+			this.statusView.show();
+			switch (e) {
+				case Events.INSTALL_START:
+					this.outputChannel.appendLine(localize('installingServiceDetailed', 'Installing {0} service to {1}', Constants.serviceName, args[0]));
+					this.statusView.text = localize('installingService', 'Installing Service');
+					break;
+				case Events.INSTALL_END:
+					this.outputChannel.appendLine(localize('serviceInstalled', 'Installed'));
+					break;
+				case Events.DOWNLOAD_START:
+					this.outputChannel.appendLine(localize('downloadingService', 'Downloading {0}', args[0]));
+					this.outputChannel.append(`(${Math.ceil(args[1] / 1024)} KB)`);
+					this.statusView.text = localize('downloadingServiceStatus', 'Downloading Service');
+					break;
+				case Events.DOWNLOAD_PROGRESS:
+					let newDots = Math.ceil(args[0] / 5);
+					if (newDots > dots) {
+						this.outputChannel.append('.'.repeat(newDots - dots));
+						dots = newDots;
+					}
+					break;
+				case Events.DOWNLOAD_END:
+					this.outputChannel.appendLine(localize('downloadingServiceComplete', 'Done!'));
+					break;
+				default:
+					break;
+			}
+		};
+	}
+}
+
+class CustomOutputChannel implements vscode.OutputChannel {
+	name: string;
+	append(value: string): void {
+	}
+	appendLine(value: string): void {
+	}
+	// tslint:disable-next-line:no-empty
+	clear(): void {
+	}
+	show(preserveFocus?: boolean): void;
+	show(column?: vscode.ViewColumn, preserveFocus?: boolean): void;
+	// tslint:disable-next-line:no-empty
+	show(column?: any, preserveFocus?: any): void {
+	}
+	// tslint:disable-next-line:no-empty
+	hide(): void {
+	}
+	// tslint:disable-next-line:no-empty
+	dispose(): void {
+	}
+}
+

extensions/import/src/services/serviceUtils.ts

@@ -0,0 +1,156 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as path from 'path';
+import * as crypto from 'crypto';
+import * as os from 'os';
+
+const baseConfig = require('./config.json');
+
+// The function is a duplicate of \src\paths.js. IT would be better to import path.js but it doesn't
+// work for now because the extension is running in different process.
+export function getAppDataPath(): string {
+	let platform = process.platform;
+	switch (platform) {
+		case 'win32': return process.env['APPDATA'] || path.join(process.env['USERPROFILE'], 'AppData', 'Roaming');
+		case 'darwin': return path.join(os.homedir(), 'Library', 'Application Support');
+		case 'linux': return process.env['XDG_CONFIG_HOME'] || path.join(os.homedir(), '.config');
+		default: throw new Error('Platform not supported');
+	}
+}
+
+export function getDefaultLogLocation(): string {
+	return path.join(getAppDataPath(), 'sqlops');
+}
+
+export function ensure(target: object, key: string): any {
+	if (target[key] === void 0) {
+		target[key] = {} as any;
+	}
+	return target[key];
+}
+
+export interface IPackageInfo {
+	name: string;
+	version: string;
+	aiKey: string;
+}
+
+export function getPackageInfo(packageJson: any): IPackageInfo {
+	if (packageJson) {
+		return {
+			name: packageJson.name,
+			version: packageJson.version,
+			aiKey: packageJson.aiKey
+		};
+	}
+}
+
+export function generateUserId(): Promise<string> {
+	return new Promise<string>(resolve => {
+		try {
+			let interfaces = os.networkInterfaces();
+			let mac;
+			for (let key of Object.keys(interfaces)) {
+				let item = interfaces[key][0];
+				if (!item.internal) {
+					mac = item.mac;
+					break;
+				}
+			}
+			if (mac) {
+				resolve(crypto.createHash('sha256').update(mac + os.homedir(), 'utf8').digest('hex'));
+			} else {
+				resolve(generateGuid());
+			}
+		} catch (err) {
+			resolve(generateGuid()); // fallback
+		}
+	});
+}
+
+export function generateGuid(): string {
+	let hexValues: string[] = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'];
+	// c.f. rfc4122 (UUID version 4 = xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx)
+	let oct: string = '';
+	let tmp: number;
+	/* tslint:disable:no-bitwise */
+	for (let a: number = 0; a < 4; a++) {
+		tmp = (4294967296 * Math.random()) | 0;
+		oct += hexValues[tmp & 0xF] +
+			hexValues[tmp >> 4 & 0xF] +
+			hexValues[tmp >> 8 & 0xF] +
+			hexValues[tmp >> 12 & 0xF] +
+			hexValues[tmp >> 16 & 0xF] +
+			hexValues[tmp >> 20 & 0xF] +
+			hexValues[tmp >> 24 & 0xF] +
+			hexValues[tmp >> 28 & 0xF];
+	}
+
+	// 'Set the two most significant bits (bits 6 and 7) of the clock_seq_hi_and_reserved to zero and one, respectively'
+	let clockSequenceHi: string = hexValues[8 + (Math.random() * 4) | 0];
+	return oct.substr(0, 8) + '-' + oct.substr(9, 4) + '-4' + oct.substr(13, 3) + '-' + clockSequenceHi + oct.substr(16, 3) + '-' + oct.substr(19, 12);
+	/* tslint:enable:no-bitwise */
+}
+
+export function verifyPlatform(): Thenable<boolean> {
+	if (os.platform() === 'darwin' && parseFloat(os.release()) < 16.0) {
+		return Promise.resolve(false);
+	} else {
+		return Promise.resolve(true);
+	}
+}
+
+export function getServiceInstallConfig(basePath?: string): any {
+	if (!basePath) {
+		basePath = __dirname;
+	}
+	let config = JSON.parse(JSON.stringify(baseConfig));
+	config.installDirectory = path.join(basePath, config.installDirectory);
+
+	return config;
+}
+
+export function getResolvedServiceInstallationPath(runtime: Runtime, basePath?: string): string {
+	let config = getServiceInstallConfig(basePath);
+	let dir = config.installDirectory;
+	dir = dir.replace('{#version#}', config.version);
+	dir = dir.replace('{#platform#}', getRuntimeDisplayName(runtime));
+
+	return dir;
+}
+
+export function getRuntimeDisplayName(runtime: Runtime): string {
+	switch (runtime) {
+		case Runtime.Windows_64:
+			return 'Windows';
+		case Runtime.Windows_86:
+			return 'Windows';
+		case Runtime.OSX:
+			return 'OSX';
+		case Runtime.Linux_64:
+			return 'Linux';
+		default:
+			return 'Unknown';
+	}
+}
+
+export enum Runtime {
+	Unknown = <any>'Unknown',
+	Windows_86 = <any>'Windows_86',
+	Windows_64 = <any>'Windows_64',
+	OSX = <any>'OSX',
+	CentOS_7 = <any>'CentOS_7',
+	Debian_8 = <any>'Debian_8',
+	Fedora_23 = <any>'Fedora_23',
+	OpenSUSE_13_2 = <any>'OpenSUSE_13_2',
+	SLES_12_2 = <any>'SLES_12_2',
+	RHEL_7 = <any>'RHEL_7',
+	Ubuntu_14 = <any>'Ubuntu_14',
+	Ubuntu_16 = <any>'Ubuntu_16',
+	Linux_64 = <any>'Linux_64',
+	Linux_86 = <any>'Linux-86'
+}

extensions/import/src/services/telemetry.ts

@@ -0,0 +1,216 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { ErrorAction, CloseAction } from 'vscode-languageclient';
+import TelemetryReporter from 'vscode-extension-telemetry';
+import { PlatformInformation } from 'service-downloader/out/platform';
+import * as opener from 'opener';
+import * as vscode from 'vscode';
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+
+import * as constants from '../constants';
+import * as serviceUtils from './serviceUtils';
+import { IMessage, ITelemetryEventProperties, ITelemetryEventMeasures } from './contracts';
+
+
+/**
+ * Handle Language Service client errors
+ * @class LanguageClientErrorHandler
+ */
+export class LanguageClientErrorHandler {
+
+    /**
+     * Creates an instance of LanguageClientErrorHandler.
+     * @memberOf LanguageClientErrorHandler
+     */
+	constructor() {
+
+	}
+
+    /**
+     * Show an error message prompt with a link to known issues wiki page
+     * @memberOf LanguageClientErrorHandler
+     */
+	showOnErrorPrompt(): void {
+		// TODO add telemetry
+		// Telemetry.sendTelemetryEvent('SqlToolsServiceCrash');
+		let crashButtonText = localize('import.serviceCrashButton', 'Give Feedback');
+		vscode.window.showErrorMessage(
+			localize('serviceCrashMessage', 'service component could not start'),
+			crashButtonText
+		).then(action => {
+			if (action && action === crashButtonText) {
+				opener(constants.serviceCrashLink);
+			}
+		});
+	}
+
+    /**
+     * Callback for language service client error
+     *
+     * @param {Error} error
+     * @param {Message} message
+     * @param {number} count
+     * @returns {ErrorAction}
+     *
+     * @memberOf LanguageClientErrorHandler
+     */
+	error(error: Error, message: IMessage, count: number): ErrorAction {
+		this.showOnErrorPrompt();
+
+		// we don't retry running the service since crashes leave the extension
+		// in a bad, unrecovered state
+		return ErrorAction.Shutdown;
+	}
+
+    /**
+     * Callback for language service client closed
+     *
+     * @returns {CloseAction}
+     *
+     * @memberOf LanguageClientErrorHandler
+     */
+	closed(): CloseAction {
+		this.showOnErrorPrompt();
+
+		// we don't retry running the service since crashes leave the extension
+		// in a bad, unrecovered state
+		return CloseAction.DoNotRestart;
+	}
+}
+
+/**
+ * Filters error paths to only include source files. Exported to support testing
+ */
+export function FilterErrorPath(line: string): string {
+	if (line) {
+		let values: string[] = line.split('/out/');
+		if (values.length <= 1) {
+			// Didn't match expected format
+			return line;
+		} else {
+			return values[1];
+		}
+	}
+}
+
+export class Telemetry {
+	private static reporter: TelemetryReporter;
+	private static userId: string;
+	private static platformInformation: PlatformInformation;
+	private static disabled: boolean;
+
+	// Get the unique ID for the current user of the extension
+	public static getUserId(): Promise<string> {
+		return new Promise<string>(resolve => {
+			// Generate the user id if it has not been created already
+			if (typeof this.userId === 'undefined') {
+				let id = serviceUtils.generateUserId();
+				id.then(newId => {
+					this.userId = newId;
+					resolve(this.userId);
+				});
+			} else {
+				resolve(this.userId);
+			}
+		});
+	}
+
+	public static getPlatformInformation(): Promise<PlatformInformation> {
+		if (this.platformInformation) {
+			return Promise.resolve(this.platformInformation);
+		} else {
+			return new Promise<PlatformInformation>(resolve => {
+				PlatformInformation.getCurrent().then(info => {
+					this.platformInformation = info;
+					resolve(this.platformInformation);
+				});
+			});
+		}
+	}
+
+    /**
+     * Disable telemetry reporting
+     */
+	public static disable(): void {
+		this.disabled = true;
+	}
+
+    /**
+     * Initialize the telemetry reporter for use.
+     */
+	public static initialize(): void {
+		if (typeof this.reporter === 'undefined') {
+			// Check if the user has opted out of telemetry
+			if (!vscode.workspace.getConfiguration('telemetry').get<boolean>('enableTelemetry', true)) {
+				this.disable();
+				return;
+			}
+			let packageInfo = vscode.extensions.getExtension('Microsoft.import').packageJSON;
+			this.reporter = new TelemetryReporter(packageInfo.name, packageInfo.version, packageInfo.aiKey);
+		}
+	}
+
+    /**
+     * Send a telemetry event for an exception
+     */
+	public static sendTelemetryEventForException(
+		err: any, methodName: string, extensionConfigName: string): void {
+		try {
+			let stackArray: string[];
+			let firstLine: string = '';
+			if (err !== undefined && err.stack !== undefined) {
+				stackArray = err.stack.split('\n');
+				if (stackArray !== undefined && stackArray.length >= 2) {
+					firstLine = stackArray[1]; // The fist line is the error message and we don't want to send that telemetry event
+					firstLine = FilterErrorPath(firstLine);
+				}
+			}
+
+			// Only adding the method name and the fist line of the stack trace. We don't add the error message because it might have PII
+			this.sendTelemetryEvent('Exception', { methodName: methodName, errorLine: firstLine });
+			// Utils.logDebug('Unhandled Exception occurred. error: ' + err + ' method: ' + methodName, extensionConfigName);
+		} catch (telemetryErr) {
+			// If sending telemetry event fails ignore it so it won't break the extension
+			// Utils.logDebug('Failed to send telemetry event. error: ' + telemetryErr, extensionConfigName);
+		}
+	}
+
+    /**
+     * Send a telemetry event using application insights
+     */
+	public static sendTelemetryEvent(
+		eventName: string,
+		properties?: ITelemetryEventProperties,
+		measures?: ITelemetryEventMeasures): void {
+
+		if (typeof this.disabled === 'undefined') {
+			this.disabled = false;
+		}
+
+		if (this.disabled || typeof (this.reporter) === 'undefined') {
+			// Don't do anything if telemetry is disabled
+			return;
+		}
+
+		if (!properties || typeof properties === 'undefined') {
+			properties = {};
+		}
+
+		// Augment the properties structure with additional common properties before sending
+		Promise.all([this.getUserId(), this.getPlatformInformation()]).then(() => {
+			properties['userId'] = this.userId;
+			properties['distribution'] = (this.platformInformation && this.platformInformation.distribution) ?
+				`${this.platformInformation.distribution.name}, ${this.platformInformation.distribution.version}` : '';
+
+			this.reporter.sendTelemetryEvent(eventName, properties, measures);
+		});
+	}
+}
+
+Telemetry.initialize();