make TelemetryAppender registry extension'ish having an active method

src/vs/platform/telemetry/common/telemetry.ts

@@ -4,11 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import {Registry} from 'vs/platform/platform';
 import {TPromise} from 'vs/base/common/winjs.base';
 import {IDisposable} from 'vs/base/common/lifecycle';
 import {ITimerEvent, nullEvent} from 'vs/base/common/timer';
-import {createDecorator, ServiceIdentifier, IInstantiationService, IConstructorSignature0} from 'vs/platform/instantiation/common/instantiation';
+import {createDecorator, ServiceIdentifier, IInstantiationService, ServicesAccessor, IConstructorSignature0} from 'vs/platform/instantiation/common/instantiation';
 
 export const ITelemetryService = createDecorator<ITelemetryService>('telemetryService');
 
@@ -37,12 +36,28 @@ export interface ITelemetryService {
 	addTelemetryAppender(appender: ITelemetryAppender): IDisposable;
 }
 
-export const Extenstions = {
-	TelemetryAppenders: 'telemetry.appenders'
+export namespace Extenstions {
+
+	let _telemetryAppenderCtors: IConstructorSignature0<ITelemetryAppender>[] = [];
+
+	export const TelemetryAppenders = {
+		activate(accessor: ServicesAccessor): void {
+			const telemetryService = accessor.get(ITelemetryService);
+			const instantiationService = accessor.get(IInstantiationService);
+			for (let ctor of _telemetryAppenderCtors) {
+				const instance = instantiationService.createInstance(ctor);
+				telemetryService.addTelemetryAppender(instance);
+			}
+			// can only be done once
+			_telemetryAppenderCtors = undefined;
+		},
+		registerTelemetryAppenderDescriptor(ctor: IConstructorSignature0<ITelemetryAppender>): void {
+			_telemetryAppenderCtors.push(ctor);
+		}
+	};
 };
 
 export interface ITelemetryAppendersRegistry {
-	registerTelemetryAppenderDescriptor(ctor: IConstructorSignature0<ITelemetryAppender>): void;
 	activate(instantiationService: IInstantiationService): void;
 }
 
@@ -64,32 +79,6 @@ export interface ITelemetryAppender extends IDisposable {
 	log(eventName: string, data?: any): void;
 }
 
-export class TelemetryAppendersRegistry implements ITelemetryAppendersRegistry {
-
-	private _telemetryAppenderCtors: IConstructorSignature0<ITelemetryAppender>[];
-
-	constructor() {
-		this._telemetryAppenderCtors = [];
-	}
-
-	public registerTelemetryAppenderDescriptor(ctor: IConstructorSignature0<ITelemetryAppender>): void {
-		this._telemetryAppenderCtors.push(ctor);
-	}
-
-	public activate(instantiationService: IInstantiationService): void {
-		const service = instantiationService.getInstance(ITelemetryService);
-		for (let ctor of this._telemetryAppenderCtors) {
-			const instance = instantiationService.createInstance(ctor);
-			service.addTelemetryAppender(instance);
-		}
-
-		// can only be done once
-		this._telemetryAppenderCtors = undefined;
-	}
-}
-
-Registry.add(Extenstions.TelemetryAppenders, new TelemetryAppendersRegistry());
-
 // --- util
 
 export function anonymize(input: string): string {

src/vs/platform/telemetry/test/node/telemetryService.test.ts

@@ -175,8 +175,7 @@ suite('TelemetryService', () => {
 
 	test('TelemetryAppendersRegistry, activate', function() {
 
-		let registry = new Telemetry.TelemetryAppendersRegistry();
-		registry.registerTelemetryAppenderDescriptor(TestTelemetryAppender);
+		Telemetry.Extenstions.TelemetryAppenders.registerTelemetryAppenderDescriptor(TestTelemetryAppender);
 
 		let callCount = 0;
 		let telemetryService: Telemetry.ITelemetryService = <any> {
@@ -188,12 +187,12 @@ suite('TelemetryService', () => {
 
 		let instantiationService = InstantiationService.createInstantiationService();
 		instantiationService.addSingleton(Telemetry.ITelemetryService, telemetryService);
-		registry.activate(instantiationService);
+		instantiationService.invokeFunction(Telemetry.Extenstions.TelemetryAppenders.activate);
 		assert.equal(callCount, 1);
 
 		// registry is now active/read-only
-		assert.throws(() => registry.registerTelemetryAppenderDescriptor(TestTelemetryAppender));
-		assert.throws(() => registry.activate(instantiationService));
+		assert.throws(() => Telemetry.Extenstions.TelemetryAppenders.registerTelemetryAppenderDescriptor(TestTelemetryAppender));
+		assert.throws(() => instantiationService.invokeFunction(Telemetry.Extenstions.TelemetryAppenders.activate));
 	});
 
 	test('Disposing', sinon.test(function() {

src/vs/workbench/browser/workbench.ts

@@ -427,7 +427,7 @@ export class Workbench implements IPartService {
 		<IWorkbenchContributionsRegistry>Registry.as(WorkbenchExtensions.Workbench).setInstantiationService(this.instantiationService);
 		<IEditorRegistry>Registry.as(EditorExtensions.Editors).setInstantiationService(this.instantiationService);
 
-		Registry.as<{activate(s:IInstantiationService):void}>(TelemetryExtensions.TelemetryAppenders).activate(this.instantiationService);
+		this.instantiationService.invokeFunction(TelemetryExtensions.TelemetryAppenders.activate);
 	}
 
 	private initSettings(): void {

src/vs/workbench/parts/telemetry/node/appInsights.telemetry.contribution.ts

@@ -5,9 +5,7 @@
 
 'use strict';
 
-import Platform = require('vs/platform/platform');
-import {Extenstions, ITelemetryAppendersRegistry} from 'vs/platform/telemetry/common/telemetry';
+import {Extenstions} from 'vs/platform/telemetry/common/telemetry';
 import AppInsightsTelemetryAppender = require('vs/workbench/parts/telemetry/node/nodeAppInsightsTelemetryAppender');
 
-Platform.Registry.as<ITelemetryAppendersRegistry>(Extenstions.TelemetryAppenders)
-	.registerTelemetryAppenderDescriptor(AppInsightsTelemetryAppender.NodeAppInsightsTelemetryAppender);
\ No newline at end of file
+Extenstions.TelemetryAppenders.registerTelemetryAppenderDescriptor(AppInsightsTelemetryAppender.NodeAppInsightsTelemetryAppender);
\ No newline at end of file