SQL Operations Studio Public Preview 1 (0.23) release source code

src/vs/platform/telemetry/test/electron-browser/appInsightsAppender.test.ts

@@ -0,0 +1,144 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 assert from 'assert';
+import { AppInsightsAppender } from 'vs/platform/telemetry/node/appInsightsAppender';
+
+interface IAppInsightsEvent {
+	eventName: string;
+	properties?: { string?: string; };
+	measurements?: { string?: number; };
+}
+
+class AppInsightsMock {
+
+	public events: IAppInsightsEvent[] = [];
+	public IsTrackingPageView: boolean = false;
+	public exceptions: any[] = [];
+
+	public trackEvent(eventName: string, properties?: { string?: string; }, measurements?: { string?: number; }): void {
+		this.events.push({
+			eventName,
+			properties,
+			measurements
+		});
+	}
+	public trackPageView(): void {
+		this.IsTrackingPageView = true;
+	}
+
+	public trackException(exception: any): void {
+		this.exceptions.push(exception);
+	}
+
+	public sendPendingData(callback): void {
+		// called on dispose
+	}
+}
+
+suite('AIAdapter', () => {
+	var appInsightsMock: AppInsightsMock;
+	var adapter: AppInsightsAppender;
+	var prefix = 'prefix';
+
+	setup(() => {
+		appInsightsMock = new AppInsightsMock();
+		adapter = new AppInsightsAppender(prefix, undefined, () => appInsightsMock);
+	});
+
+	teardown(() => {
+		adapter.dispose();
+	});
+
+	test('Simple event', () => {
+		adapter.log('testEvent');
+
+		assert.equal(appInsightsMock.events.length, 1);
+		assert.equal(appInsightsMock.events[0].eventName, `${prefix}/testEvent`);
+	});
+
+	test('addional data', () => {
+		adapter = new AppInsightsAppender(prefix, { first: '1st', second: 2, third: true }, () => appInsightsMock);
+		adapter.log('testEvent');
+
+		assert.equal(appInsightsMock.events.length, 1);
+		let [first] = appInsightsMock.events;
+		assert.equal(first.eventName, `${prefix}/testEvent`);
+		assert.equal(first.properties['first'], '1st');
+		assert.equal(first.measurements['second'], '2');
+		assert.equal(first.measurements['third'], 1);
+	});
+
+	test('property limits', () => {
+		var reallyLongPropertyName = 'abcdefghijklmnopqrstuvwxyz';
+		for (var i = 0; i < 6; i++) {
+			reallyLongPropertyName += 'abcdefghijklmnopqrstuvwxyz';
+		}
+		assert(reallyLongPropertyName.length > 150);
+
+		var reallyLongPropertyValue = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123';
+		for (var i = 0; i < 21; i++) {
+			reallyLongPropertyValue += 'abcdefghijklmnopqrstuvwxyz012345678901234567890123';
+		}
+		assert(reallyLongPropertyValue.length > 1024);
+
+		var data = {};
+		data[reallyLongPropertyName] = '1234';
+		data['reallyLongPropertyValue'] = reallyLongPropertyValue;
+		adapter.log('testEvent', data);
+
+		assert.equal(appInsightsMock.events.length, 1);
+
+		for (var prop in appInsightsMock.events[0].properties) {
+			assert(prop.length < 150);
+			assert(appInsightsMock.events[0].properties[prop].length < 1024);
+		}
+	});
+
+	test('Different data types', () => {
+		var date = new Date();
+		adapter.log('testEvent', { favoriteDate: date, likeRed: false, likeBlue: true, favoriteNumber: 1, favoriteColor: 'blue', favoriteCars: ['bmw', 'audi', 'ford'] });
+
+		assert.equal(appInsightsMock.events.length, 1);
+		assert.equal(appInsightsMock.events[0].eventName, `${prefix}/testEvent`);
+		assert.equal(appInsightsMock.events[0].properties['favoriteColor'], 'blue');
+		assert.equal(appInsightsMock.events[0].measurements['likeRed'], 0);
+		assert.equal(appInsightsMock.events[0].measurements['likeBlue'], 1);
+		assert.equal(appInsightsMock.events[0].properties['favoriteDate'], date.toISOString());
+		assert.equal(appInsightsMock.events[0].properties['favoriteCars'], JSON.stringify(['bmw', 'audi', 'ford']));
+		assert.equal(appInsightsMock.events[0].measurements['favoriteNumber'], 1);
+	});
+
+	test('Nested data', () => {
+		adapter.log('testEvent', {
+			window: {
+				title: 'some title',
+				measurements: {
+					width: 100,
+					height: 200
+				}
+			},
+			nestedObj: {
+				nestedObj2: {
+					nestedObj3: {
+						testProperty: 'test',
+					}
+				},
+				testMeasurement: 1
+			}
+		});
+
+		assert.equal(appInsightsMock.events.length, 1);
+		assert.equal(appInsightsMock.events[0].eventName, `${prefix}/testEvent`);
+
+		assert.equal(appInsightsMock.events[0].properties['window.title'], 'some title');
+		assert.equal(appInsightsMock.events[0].measurements['window.measurements.width'], 100);
+		assert.equal(appInsightsMock.events[0].measurements['window.measurements.height'], 200);
+
+		assert.equal(appInsightsMock.events[0].properties['nestedObj.nestedObj2.nestedObj3'], JSON.stringify({ 'testProperty': 'test' }));
+		assert.equal(appInsightsMock.events[0].measurements['nestedObj.testMeasurement'], 1);
+	});
+});

src/vs/platform/telemetry/test/electron-browser/commonProperties.test.ts

@@ -0,0 +1,88 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 assert from 'assert';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { resolveWorkbenchCommonProperties } from 'vs/platform/telemetry/node/workbenchCommonProperties';
+import { StorageService, InMemoryLocalStorage } from 'vs/platform/storage/common/storageService';
+import { TestWorkspace } from 'vs/platform/workspace/test/common/testWorkspace';
+
+suite('Telemetry - common properties', function () {
+
+	const commit = void 0;
+	const version = void 0;
+	let storageService;
+
+	setup(() => {
+		storageService = new StorageService(new InMemoryLocalStorage(), null, TestWorkspace.id);
+	});
+
+	test('default', function () {
+
+		return resolveWorkbenchCommonProperties(storageService, commit, version).then(props => {
+
+			assert.ok('commitHash' in props);
+			assert.ok('sessionID' in props);
+			assert.ok('timestamp' in props);
+			assert.ok('common.platform' in props);
+			assert.ok('common.nodePlatform' in props);
+			assert.ok('common.nodeArch' in props);
+			assert.ok('common.timesincesessionstart' in props);
+			assert.ok('common.sequence' in props);
+
+			// assert.ok('common.version.shell' in first.data); // only when running on electron
+			// assert.ok('common.version.renderer' in first.data);
+			assert.ok('common.osVersion' in props, 'osVersion');
+			assert.ok('version' in props);
+
+			// {{SQL CARBON EDIT}}
+			assert.ok('common.application.name' in props);
+
+			assert.ok('common.firstSessionDate' in props, 'firstSessionDate');
+			assert.ok('common.lastSessionDate' in props, 'lastSessionDate'); // conditional, see below, 'lastSessionDate'ow
+			assert.ok('common.isNewSession' in props, 'isNewSession');
+
+			// machine id et al
+			assert.ok('common.instanceId' in props, 'instanceId');
+			assert.ok('common.machineId' in props, 'machineId');
+			if (process.platform === 'win32') { // SQM only on windows
+				assert.ok('common.sqm.userid' in props, 'userid');
+				assert.ok('common.sqm.machineid' in props, 'machineid');
+			}
+
+		});
+	});
+
+	test('lastSessionDate when aviablale', function () {
+
+		storageService.store('telemetry.lastSessionDate', new Date().toUTCString());
+
+		return resolveWorkbenchCommonProperties(storageService, commit, version).then(props => {
+
+			assert.ok('common.lastSessionDate' in props); // conditional, see below
+			assert.ok('common.isNewSession' in props);
+			assert.equal(props['common.isNewSession'], 0);
+		});
+	});
+
+	test('values chance on ask', function () {
+		return resolveWorkbenchCommonProperties(storageService, commit, version).then(props => {
+			let value1 = props['common.sequence'];
+			let value2 = props['common.sequence'];
+			assert.ok(value1 !== value2, 'seq');
+
+			value1 = props['timestamp'];
+			value2 = props['timestamp'];
+			assert.ok(value1 !== value2, 'timestamp');
+
+			value1 = props['common.timesincesessionstart'];
+			return TPromise.timeout(10).then(_ => {
+				value2 = props['common.timesincesessionstart'];
+				assert.ok(value1 !== value2, 'timesincesessionstart');
+			});
+		});
+	});
+});

src/vs/platform/telemetry/test/electron-browser/telemetryService.test.ts

@@ -0,0 +1,716 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 assert from 'assert';
+import { Emitter } from 'vs/base/common/event';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { TelemetryService } from 'vs/platform/telemetry/common/telemetryService';
+import ErrorTelemetry from 'vs/platform/telemetry/browser/errorTelemetry';
+import { NullAppender, ITelemetryAppender } from 'vs/platform/telemetry/common/telemetryUtils';
+import Errors = require('vs/base/common/errors');
+import * as sinon from 'sinon';
+import { getConfigurationValue } from 'vs/platform/configuration/common/configuration';
+
+const optInStatusEventName: string = 'optInStatus';
+
+class TestTelemetryAppender implements ITelemetryAppender {
+
+	public events: any[];
+	public isDisposed: boolean;
+
+	constructor() {
+		this.events = [];
+		this.isDisposed = false;
+	}
+
+	public log(eventName: string, data?: any): void {
+		this.events.push({ eventName, data });
+	}
+
+	public getEventsCount() {
+		return this.events.length;
+	}
+
+	public dispose() {
+		this.isDisposed = true;
+	}
+}
+
+class ErrorTestingSettings {
+	public personalInfo;
+	public importantInfo;
+	public filePrefix;
+	public dangerousPathWithoutImportantInfo;
+	public dangerousPathWithImportantInfo;
+	public missingModelPrefix;
+	public missingModelMessage;
+	public noSuchFilePrefix;
+	public noSuchFileMessage;
+	public stack;
+
+	constructor() {
+		this.personalInfo = 'DANGEROUS/PATH';
+		this.importantInfo = 'important/information';
+		this.filePrefix = 'file:///';
+		this.dangerousPathWithImportantInfo = this.filePrefix + this.personalInfo + '/resources/app/' + this.importantInfo;
+		this.dangerousPathWithoutImportantInfo = this.filePrefix + this.personalInfo;
+
+		this.missingModelPrefix = 'Received model events for missing model ';
+		this.missingModelMessage = this.missingModelPrefix + ' ' + this.dangerousPathWithoutImportantInfo;
+
+		this.noSuchFilePrefix = 'ENOENT: no such file or directory';
+		this.noSuchFileMessage = this.noSuchFilePrefix + ' \'' + this.personalInfo + '\'';
+
+		this.stack = ['at e._modelEvents (a/path/that/doesnt/contain/code/names.js:11:7309)',
+			'    at t.AllWorkers (a/path/that/doesnt/contain/code/names.js:6:8844)',
+			'    at e.(anonymous function) [as _modelEvents] (a/path/that/doesnt/contain/code/names.js:5:29552)',
+			'    at Function.<anonymous> (a/path/that/doesnt/contain/code/names.js:6:8272)',
+			'    at e.dispatch (a/path/that/doesnt/contain/code/names.js:5:26931)',
+			'    at e.request (a/path/that/doesnt/contain/code/names.js:14:1745)',
+			'    at t._handleMessage (another/path/that/doesnt/contain/code/names.js:14:17447)',
+			'    at t._onmessage (another/path/that/doesnt/contain/code/names.js:14:16976)',
+			'    at t.onmessage (another/path/that/doesnt/contain/code/names.js:14:15854)',
+			'    at DedicatedWorkerGlobalScope.self.onmessage',
+			this.dangerousPathWithImportantInfo,
+			this.dangerousPathWithoutImportantInfo,
+			this.missingModelMessage,
+			this.noSuchFileMessage];
+	}
+}
+
+suite('TelemetryService', () => {
+
+	test('Disposing', sinon.test(function () {
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ appender: testAppender }, undefined);
+
+		return service.publicLog('testPrivateEvent').then(() => {
+			assert.equal(testAppender.getEventsCount(), 1);
+
+			service.dispose();
+			assert.equal(!testAppender.isDisposed, true);
+		});
+	}));
+
+	// event reporting
+	test('Simple event', sinon.test(function () {
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ appender: testAppender }, undefined);
+
+		return service.publicLog('testEvent').then(_ => {
+			assert.equal(testAppender.getEventsCount(), 1);
+			assert.equal(testAppender.events[0].eventName, 'testEvent');
+			assert.notEqual(testAppender.events[0].data, null);
+
+			service.dispose();
+		});
+	}));
+
+	test('Event with data', sinon.test(function () {
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ appender: testAppender }, undefined);
+
+		return service.publicLog('testEvent', {
+			'stringProp': 'property',
+			'numberProp': 1,
+			'booleanProp': true,
+			'complexProp': {
+				'value': 0
+			}
+		}).then(() => {
+			assert.equal(testAppender.getEventsCount(), 1);
+			assert.equal(testAppender.events[0].eventName, 'testEvent');
+			assert.notEqual(testAppender.events[0].data, null);
+			assert.equal(testAppender.events[0].data['stringProp'], 'property');
+			assert.equal(testAppender.events[0].data['numberProp'], 1);
+			assert.equal(testAppender.events[0].data['booleanProp'], true);
+			assert.equal(testAppender.events[0].data['complexProp'].value, 0);
+
+			service.dispose();
+		});
+
+	}));
+
+	test('common properties added to *all* events, simple event', function () {
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({
+			appender: testAppender,
+			commonProperties: TPromise.as({ foo: 'JA!', get bar() { return Math.random(); } })
+		}, undefined);
+
+		return service.publicLog('testEvent').then(_ => {
+			let [first] = testAppender.events;
+
+			assert.equal(Object.keys(first.data).length, 2);
+			assert.equal(typeof first.data['foo'], 'string');
+			assert.equal(typeof first.data['bar'], 'number');
+
+			service.dispose();
+		});
+	});
+
+	test('common properties added to *all* events, event with data', function () {
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({
+			appender: testAppender,
+			commonProperties: TPromise.as({ foo: 'JA!', get bar() { return Math.random(); } })
+		}, undefined);
+
+		return service.publicLog('testEvent', { hightower: 'xl', price: 8000 }).then(_ => {
+			let [first] = testAppender.events;
+
+			assert.equal(Object.keys(first.data).length, 4);
+			assert.equal(typeof first.data['foo'], 'string');
+			assert.equal(typeof first.data['bar'], 'number');
+			assert.equal(typeof first.data['hightower'], 'string');
+			assert.equal(typeof first.data['price'], 'number');
+
+			service.dispose();
+		});
+	});
+
+	test('TelemetryInfo comes from properties', function () {
+		let service = new TelemetryService({
+			appender: NullAppender,
+			commonProperties: TPromise.as({
+				sessionID: 'one',
+				['common.instanceId']: 'two',
+				['common.machineId']: 'three',
+			})
+		}, undefined);
+
+		return service.getTelemetryInfo().then(info => {
+			assert.equal(info.sessionId, 'one');
+			assert.equal(info.instanceId, 'two');
+			assert.equal(info.machineId, 'three');
+
+			service.dispose();
+		});
+	});
+
+	test('enableTelemetry on by default', sinon.test(function () {
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ appender: testAppender }, undefined);
+
+		return service.publicLog('testEvent').then(() => {
+			assert.equal(testAppender.getEventsCount(), 1);
+			assert.equal(testAppender.events[0].eventName, 'testEvent');
+
+			service.dispose();
+		});
+	}));
+
+	test('Error events', sinon.test(function () {
+
+		let origErrorHandler = Errors.errorHandler.getUnexpectedErrorHandler();
+		Errors.setUnexpectedErrorHandler(() => { });
+
+		try {
+			let testAppender = new TestTelemetryAppender();
+			let service = new TelemetryService({ appender: testAppender }, undefined);
+			const errorTelemetry = new ErrorTelemetry(service);
+
+
+			let e: any = new Error('This is a test.');
+			// for Phantom
+			if (!e.stack) {
+				e.stack = 'blah';
+			}
+
+			Errors.onUnexpectedError(e);
+			this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+			assert.equal(testAppender.getEventsCount(), 1);
+			assert.equal(testAppender.events[0].eventName, 'UnhandledError');
+			assert.equal(testAppender.events[0].data.message, 'This is a test.');
+
+			errorTelemetry.dispose();
+			service.dispose();
+		} finally {
+			Errors.setUnexpectedErrorHandler(origErrorHandler);
+		}
+	}));
+
+	// 	test('Unhandled Promise Error events', sinon.test(function() {
+	//
+	// 		let origErrorHandler = Errors.errorHandler.getUnexpectedErrorHandler();
+	// 		Errors.setUnexpectedErrorHandler(() => {});
+	//
+	// 		try {
+	// 			let service = new MainTelemetryService();
+	// 			let testAppender = new TestTelemetryAppender();
+	// 			service.addTelemetryAppender(testAppender);
+	//
+	// 			winjs.Promise.wrapError(new Error('This should not get logged'));
+	// 			winjs.TPromise.as(true).then(() => {
+	// 				throw new Error('This should get logged');
+	// 			});
+	// 			// prevent console output from failing the test
+	// 			this.stub(console, 'log');
+	// 			// allow for the promise to finish
+	// 			this.clock.tick(MainErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+	//
+	// 			assert.equal(testAppender.getEventsCount(), 1);
+	// 			assert.equal(testAppender.events[0].eventName, 'UnhandledError');
+	// 			assert.equal(testAppender.events[0].data.message,  'This should get logged');
+	//
+	// 			service.dispose();
+	// 		} finally {
+	// 			Errors.setUnexpectedErrorHandler(origErrorHandler);
+	// 		}
+	// 	}));
+
+	test('Handle global errors', sinon.test(function () {
+		let errorStub = sinon.stub();
+		window.onerror = errorStub;
+
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ appender: testAppender }, undefined);
+		const errorTelemetry = new ErrorTelemetry(service);
+
+		let testError = new Error('test');
+		(<any>window.onerror)('Error Message', 'file.js', 2, 42, testError);
+		this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+		assert.equal(errorStub.alwaysCalledWithExactly('Error Message', 'file.js', 2, 42, testError), true);
+		assert.equal(errorStub.callCount, 1);
+
+		assert.equal(testAppender.getEventsCount(), 1);
+		assert.equal(testAppender.events[0].eventName, 'UnhandledError');
+		assert.equal(testAppender.events[0].data.message, 'Error Message');
+		assert.equal(testAppender.events[0].data.filename, 'file.js');
+		assert.equal(testAppender.events[0].data.line, 2);
+		assert.equal(testAppender.events[0].data.column, 42);
+		assert.equal(testAppender.events[0].data.error.message, 'test');
+
+		errorTelemetry.dispose();
+		service.dispose();
+	}));
+
+	test('Uncaught Error Telemetry removes PII from filename', sinon.test(function () {
+		let errorStub = sinon.stub();
+		window.onerror = errorStub;
+		let settings = new ErrorTestingSettings();
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ appender: testAppender }, undefined);
+		const errorTelemetry = new ErrorTelemetry(service);
+
+		let dangerousFilenameError: any = new Error('dangerousFilename');
+		dangerousFilenameError.stack = settings.stack;
+		(<any>window.onerror)('dangerousFilename', settings.dangerousPathWithImportantInfo + '/test.js', 2, 42, dangerousFilenameError);
+		this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+		assert.equal(errorStub.callCount, 1);
+		assert.equal(testAppender.events[0].data.filename.indexOf(settings.dangerousPathWithImportantInfo), -1);
+
+		dangerousFilenameError = new Error('dangerousFilename');
+		dangerousFilenameError.stack = settings.stack;
+		(<any>window.onerror)('dangerousFilename', settings.dangerousPathWithImportantInfo + '/test.js', 2, 42, dangerousFilenameError);
+		this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+		assert.equal(errorStub.callCount, 2);
+		assert.equal(testAppender.events[0].data.filename.indexOf(settings.dangerousPathWithImportantInfo), -1);
+		assert.equal(testAppender.events[0].data.filename, settings.importantInfo + '/test.js');
+
+		errorTelemetry.dispose();
+		service.dispose();
+	}));
+
+	test('Unexpected Error Telemetry removes PII', sinon.test(function () {
+		let origErrorHandler = Errors.errorHandler.getUnexpectedErrorHandler();
+		Errors.setUnexpectedErrorHandler(() => { });
+		try {
+			let settings = new ErrorTestingSettings();
+			let testAppender = new TestTelemetryAppender();
+			let service = new TelemetryService({ appender: testAppender }, undefined);
+			const errorTelemetry = new ErrorTelemetry(service);
+
+			let dangerousPathWithoutImportantInfoError: any = new Error(settings.dangerousPathWithoutImportantInfo);
+			dangerousPathWithoutImportantInfoError.stack = settings.stack;
+			Errors.onUnexpectedError(dangerousPathWithoutImportantInfoError);
+			this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.filePrefix), -1);
+
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.filePrefix), -1);
+			assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.stack[4]), -1);
+			assert.equal(testAppender.events[0].data.stack.split('\n').length, settings.stack.length);
+
+			errorTelemetry.dispose();
+			service.dispose();
+		}
+		finally {
+			Errors.setUnexpectedErrorHandler(origErrorHandler);
+		}
+	}));
+
+	test('Uncaught Error Telemetry removes PII', sinon.test(function () {
+		let errorStub = sinon.stub();
+		window.onerror = errorStub;
+		let settings = new ErrorTestingSettings();
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ appender: testAppender }, undefined);
+		const errorTelemetry = new ErrorTelemetry(service);
+
+		let dangerousPathWithoutImportantInfoError: any = new Error('dangerousPathWithoutImportantInfo');
+		dangerousPathWithoutImportantInfoError.stack = settings.stack;
+		(<any>window.onerror)(settings.dangerousPathWithoutImportantInfo, 'test.js', 2, 42, dangerousPathWithoutImportantInfoError);
+		this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+		assert.equal(errorStub.callCount, 1);
+		// Test that no file information remains, esp. personal info
+		assert.equal(testAppender.events[0].data.message.indexOf(settings.personalInfo), -1);
+		assert.equal(testAppender.events[0].data.message.indexOf(settings.filePrefix), -1);
+		assert.equal(testAppender.events[0].data.stack.indexOf(settings.personalInfo), -1);
+		assert.equal(testAppender.events[0].data.stack.indexOf(settings.filePrefix), -1);
+		assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.stack[4]), -1);
+		assert.equal(testAppender.events[0].data.stack.split('\n').length, settings.stack.length);
+
+		errorTelemetry.dispose();
+		service.dispose();
+	}));
+
+	test('Unexpected Error Telemetry removes PII but preserves Code file path', sinon.test(function () {
+
+		let origErrorHandler = Errors.errorHandler.getUnexpectedErrorHandler();
+		Errors.setUnexpectedErrorHandler(() => { });
+
+		try {
+			let settings = new ErrorTestingSettings();
+			let testAppender = new TestTelemetryAppender();
+			let service = new TelemetryService({ appender: testAppender }, undefined);
+			const errorTelemetry = new ErrorTelemetry(service);
+
+			let dangerousPathWithImportantInfoError: any = new Error(settings.dangerousPathWithImportantInfo);
+			dangerousPathWithImportantInfoError.stack = settings.stack;
+
+			// Test that important information remains but personal info does not
+			Errors.onUnexpectedError(dangerousPathWithImportantInfoError);
+			this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+			assert.notEqual(testAppender.events[0].data.message.indexOf(settings.importantInfo), -1);
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.filePrefix), -1);
+			assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.importantInfo), -1);
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.filePrefix), -1);
+			assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.stack[4]), -1);
+			assert.equal(testAppender.events[0].data.stack.split('\n').length, settings.stack.length);
+
+			errorTelemetry.dispose();
+			service.dispose();
+		}
+		finally {
+			Errors.setUnexpectedErrorHandler(origErrorHandler);
+		}
+	}));
+
+	test('Uncaught Error Telemetry removes PII but preserves Code file path', sinon.test(function () {
+		let errorStub = sinon.stub();
+		window.onerror = errorStub;
+		let settings = new ErrorTestingSettings();
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ appender: testAppender }, undefined);
+		const errorTelemetry = new ErrorTelemetry(service);
+
+		let dangerousPathWithImportantInfoError: any = new Error('dangerousPathWithImportantInfo');
+		dangerousPathWithImportantInfoError.stack = settings.stack;
+		(<any>window.onerror)(settings.dangerousPathWithImportantInfo, 'test.js', 2, 42, dangerousPathWithImportantInfoError);
+		this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+		assert.equal(errorStub.callCount, 1);
+		// Test that important information remains but personal info does not
+		assert.notEqual(testAppender.events[0].data.message.indexOf(settings.importantInfo), -1);
+		assert.equal(testAppender.events[0].data.message.indexOf(settings.personalInfo), -1);
+		assert.equal(testAppender.events[0].data.message.indexOf(settings.filePrefix), -1);
+		assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.importantInfo), -1);
+		assert.equal(testAppender.events[0].data.stack.indexOf(settings.personalInfo), -1);
+		assert.equal(testAppender.events[0].data.stack.indexOf(settings.filePrefix), -1);
+		assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.stack[4]), -1);
+		assert.equal(testAppender.events[0].data.stack.split('\n').length, settings.stack.length);
+
+		errorTelemetry.dispose();
+		service.dispose();
+	}));
+
+	test('Unexpected Error Telemetry removes PII but preserves Code file path when PIIPath is configured', sinon.test(function () {
+
+		let origErrorHandler = Errors.errorHandler.getUnexpectedErrorHandler();
+		Errors.setUnexpectedErrorHandler(() => { });
+
+		try {
+			let settings = new ErrorTestingSettings();
+			let testAppender = new TestTelemetryAppender();
+			let service = new TelemetryService({ appender: testAppender, piiPaths: [settings.personalInfo + '/resources/app/'] }, undefined);
+			const errorTelemetry = new ErrorTelemetry(service);
+
+			let dangerousPathWithImportantInfoError: any = new Error(settings.dangerousPathWithImportantInfo);
+			dangerousPathWithImportantInfoError.stack = settings.stack;
+
+			// Test that important information remains but personal info does not
+			Errors.onUnexpectedError(dangerousPathWithImportantInfoError);
+			this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+			assert.notEqual(testAppender.events[0].data.message.indexOf(settings.importantInfo), -1);
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.filePrefix), -1);
+			assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.importantInfo), -1);
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.filePrefix), -1);
+			assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.stack[4]), -1);
+			assert.equal(testAppender.events[0].data.stack.split('\n').length, settings.stack.length);
+
+			errorTelemetry.dispose();
+			service.dispose();
+		}
+		finally {
+			Errors.setUnexpectedErrorHandler(origErrorHandler);
+		}
+	}));
+
+	test('Uncaught Error Telemetry removes PII but preserves Code file path when PIIPath is configured', sinon.test(function () {
+		let errorStub = sinon.stub();
+		window.onerror = errorStub;
+		let settings = new ErrorTestingSettings();
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ appender: testAppender, piiPaths: [settings.personalInfo + '/resources/app/'] }, undefined);
+		const errorTelemetry = new ErrorTelemetry(service);
+
+		let dangerousPathWithImportantInfoError: any = new Error('dangerousPathWithImportantInfo');
+		dangerousPathWithImportantInfoError.stack = settings.stack;
+		(<any>window.onerror)(settings.dangerousPathWithImportantInfo, 'test.js', 2, 42, dangerousPathWithImportantInfoError);
+		this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+		assert.equal(errorStub.callCount, 1);
+		// Test that important information remains but personal info does not
+		assert.notEqual(testAppender.events[0].data.message.indexOf(settings.importantInfo), -1);
+		assert.equal(testAppender.events[0].data.message.indexOf(settings.personalInfo), -1);
+		assert.equal(testAppender.events[0].data.message.indexOf(settings.filePrefix), -1);
+		assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.importantInfo), -1);
+		assert.equal(testAppender.events[0].data.stack.indexOf(settings.personalInfo), -1);
+		assert.equal(testAppender.events[0].data.stack.indexOf(settings.filePrefix), -1);
+		assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.stack[4]), -1);
+		assert.equal(testAppender.events[0].data.stack.split('\n').length, settings.stack.length);
+
+		errorTelemetry.dispose();
+		service.dispose();
+	}));
+
+	test('Unexpected Error Telemetry removes PII but preserves Missing Model error message', sinon.test(function () {
+
+		let origErrorHandler = Errors.errorHandler.getUnexpectedErrorHandler();
+		Errors.setUnexpectedErrorHandler(() => { });
+
+		try {
+			let settings = new ErrorTestingSettings();
+			let testAppender = new TestTelemetryAppender();
+			let service = new TelemetryService({ appender: testAppender }, undefined);
+			const errorTelemetry = new ErrorTelemetry(service);
+
+			let missingModelError: any = new Error(settings.missingModelMessage);
+			missingModelError.stack = settings.stack;
+
+			// Test that no file information remains, but this particular
+			// error message does (Received model events for missing model)
+			Errors.onUnexpectedError(missingModelError);
+			this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+			assert.notEqual(testAppender.events[0].data.message.indexOf(settings.missingModelPrefix), -1);
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.filePrefix), -1);
+			assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.missingModelPrefix), -1);
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.filePrefix), -1);
+			assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.stack[4]), -1);
+			assert.equal(testAppender.events[0].data.stack.split('\n').length, settings.stack.length);
+
+			errorTelemetry.dispose();
+			service.dispose();
+		} finally {
+			Errors.setUnexpectedErrorHandler(origErrorHandler);
+		}
+	}));
+
+	test('Uncaught Error Telemetry removes PII but preserves Missing Model error message', sinon.test(function () {
+		let errorStub = sinon.stub();
+		window.onerror = errorStub;
+		let settings = new ErrorTestingSettings();
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ appender: testAppender }, undefined);
+		const errorTelemetry = new ErrorTelemetry(service);
+
+		let missingModelError: any = new Error('missingModelMessage');
+		missingModelError.stack = settings.stack;
+		(<any>window.onerror)(settings.missingModelMessage, 'test.js', 2, 42, missingModelError);
+		this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+		assert.equal(errorStub.callCount, 1);
+		// Test that no file information remains, but this particular
+		// error message does (Received model events for missing model)
+		assert.notEqual(testAppender.events[0].data.message.indexOf(settings.missingModelPrefix), -1);
+		assert.equal(testAppender.events[0].data.message.indexOf(settings.personalInfo), -1);
+		assert.equal(testAppender.events[0].data.message.indexOf(settings.filePrefix), -1);
+		assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.missingModelPrefix), -1);
+		assert.equal(testAppender.events[0].data.stack.indexOf(settings.personalInfo), -1);
+		assert.equal(testAppender.events[0].data.stack.indexOf(settings.filePrefix), -1);
+		assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.stack[4]), -1);
+		assert.equal(testAppender.events[0].data.stack.split('\n').length, settings.stack.length);
+
+		errorTelemetry.dispose();
+		service.dispose();
+	}));
+
+	test('Unexpected Error Telemetry removes PII but preserves No Such File error message', sinon.test(function () {
+
+		let origErrorHandler = Errors.errorHandler.getUnexpectedErrorHandler();
+		Errors.setUnexpectedErrorHandler(() => { });
+
+		try {
+			let settings = new ErrorTestingSettings();
+			let testAppender = new TestTelemetryAppender();
+			let service = new TelemetryService({ appender: testAppender }, undefined);
+			const errorTelemetry = new ErrorTelemetry(service);
+
+			let noSuchFileError: any = new Error(settings.noSuchFileMessage);
+			noSuchFileError.stack = settings.stack;
+
+			// Test that no file information remains, but this particular
+			// error message does (ENOENT: no such file or directory)
+			Errors.onUnexpectedError(noSuchFileError);
+			this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+			assert.notEqual(testAppender.events[0].data.message.indexOf(settings.noSuchFilePrefix), -1);
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.filePrefix), -1);
+			assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.noSuchFilePrefix), -1);
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.filePrefix), -1);
+			assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.stack[4]), -1);
+			assert.equal(testAppender.events[0].data.stack.split('\n').length, settings.stack.length);
+
+			errorTelemetry.dispose();
+			service.dispose();
+		} finally {
+			Errors.setUnexpectedErrorHandler(origErrorHandler);
+		}
+	}));
+
+	test('Uncaught Error Telemetry removes PII but preserves No Such File error message', sinon.test(function () {
+		let origErrorHandler = Errors.errorHandler.getUnexpectedErrorHandler();
+		Errors.setUnexpectedErrorHandler(() => { });
+
+		try {
+			let errorStub = sinon.stub();
+			window.onerror = errorStub;
+			let settings = new ErrorTestingSettings();
+			let testAppender = new TestTelemetryAppender();
+			let service = new TelemetryService({ appender: testAppender }, undefined);
+			const errorTelemetry = new ErrorTelemetry(service);
+
+			let noSuchFileError: any = new Error('noSuchFileMessage');
+			noSuchFileError.stack = settings.stack;
+			(<any>window.onerror)(settings.noSuchFileMessage, 'test.js', 2, 42, noSuchFileError);
+			this.clock.tick(ErrorTelemetry.ERROR_FLUSH_TIMEOUT);
+
+			assert.equal(errorStub.callCount, 1);
+			// Test that no file information remains, but this particular
+			// error message does (ENOENT: no such file or directory)
+			Errors.onUnexpectedError(noSuchFileError);
+			assert.notEqual(testAppender.events[0].data.message.indexOf(settings.noSuchFilePrefix), -1);
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.message.indexOf(settings.filePrefix), -1);
+			assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.noSuchFilePrefix), -1);
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.personalInfo), -1);
+			assert.equal(testAppender.events[0].data.stack.indexOf(settings.filePrefix), -1);
+			assert.notEqual(testAppender.events[0].data.stack.indexOf(settings.stack[4]), -1);
+			assert.equal(testAppender.events[0].data.stack.split('\n').length, settings.stack.length);
+
+			errorTelemetry.dispose();
+			service.dispose();
+		} finally {
+			Errors.setUnexpectedErrorHandler(origErrorHandler);
+		}
+	}));
+
+	test('Telemetry Service respects user opt-in settings', sinon.test(function () {
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ userOptIn: false, appender: testAppender }, undefined);
+
+		return service.publicLog('testEvent').then(() => {
+			assert.equal(testAppender.getEventsCount(), 0);
+			service.dispose();
+		});
+	}));
+
+	test('Telemetry Service does not sent optInStatus when user opted out', sinon.test(function () {
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ userOptIn: false, appender: testAppender }, undefined);
+
+		return service.publicLog(optInStatusEventName, { optIn: false }).then(() => {
+			assert.equal(testAppender.getEventsCount(), 0);
+			service.dispose();
+		});
+	}));
+
+	test('Telemetry Service sends events when enableTelemetry is on even user optin is on', sinon.test(function () {
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({ userOptIn: true, appender: testAppender }, undefined);
+
+		return service.publicLog('testEvent').then(() => {
+			assert.equal(testAppender.getEventsCount(), 1);
+			service.dispose();
+		});
+	}));
+
+	test('Telemetry Service checks with config service', function () {
+
+		let enableTelemetry = false;
+		let emitter = new Emitter<any>();
+
+		let testAppender = new TestTelemetryAppender();
+		let service = new TelemetryService({
+			appender: testAppender
+		}, {
+				_serviceBrand: undefined,
+				getConfiguration() {
+					return {
+						enableTelemetry: enableTelemetry
+					} as any;
+				},
+				getConfigurationData(): any {
+					return null;
+				},
+				reloadConfiguration() {
+					return TPromise.as(this.getConfiguration());
+				},
+				lookup(key: string) {
+					return {
+						value: getConfigurationValue(this.getConfiguration(), key),
+						default: getConfigurationValue(this.getConfiguration(), key),
+						user: getConfigurationValue(this.getConfiguration(), key),
+						workspace: null,
+						folder: null
+					};
+				},
+				keys() { return { default: [], user: [], workspace: [], folder: [] }; },
+				values() { return {}; },
+				onDidUpdateConfiguration: emitter.event
+			});
+
+		assert.equal(service.isOptedIn, false);
+
+		enableTelemetry = true;
+		emitter.fire({});
+		assert.equal(service.isOptedIn, true);
+
+		enableTelemetry = false;
+		emitter.fire({});
+		assert.equal(service.isOptedIn, false);
+
+		service.dispose();
+	});
+});