#39574 Implement log level transmission to extension host

src/vs/platform/log/common/log.ts

@@ -239,20 +239,19 @@ export class MultiplexLogService extends AbstractLogService implements ILogServi
 	}
 }
 
-export class FollowerLogService extends Disposable implements ILogService {
+export class DelegatedLogService extends Disposable implements ILogService {
 	_serviceBrand: any;
 
-	constructor(private master: ILogLevelSetter, private logService: ILogService) {
+	constructor(private logService: ILogService) {
 		super();
-		this._register(master.onDidChangeLogLevel(level => logService.setLevel(level)));
 	}
 
 	get onDidChangeLogLevel(): Event<LogLevel> {
 		return this.logService.onDidChangeLogLevel;
 	}
 
 	setLevel(level: LogLevel): void {
-		this.master.setLevel(level);
+		this.logService.setLevel(level);
 	}
 
 	getLevel(): LogLevel {
@@ -288,6 +287,19 @@ export class FollowerLogService extends Disposable implements ILogService {
 	}
 }
 
+export class FollowerLogService extends DelegatedLogService implements ILogService {
+	_serviceBrand: any;
+
+	constructor(private master: ILogLevelSetter, logService: ILogService) {
+		super(logService);
+		this._register(master.onDidChangeLogLevel(level => logService.setLevel(level)));
+	}
+
+	setLevel(level: LogLevel): void {
+		this.master.setLevel(level);
+	}
+}
+
 export class NullLogService implements ILogService {
 	_serviceBrand: any;
 	readonly onDidChangeLogLevel: Event<LogLevel> = new Emitter<LogLevel>().event;

src/vs/workbench/api/electron-browser/extensionHost.contribution.ts

@@ -46,6 +46,7 @@ import './mainThreadTask';
 import './mainThreadTelemetry';
 import './mainThreadTerminalService';
 import './mainThreadTreeViews';
+import './mainThreadLogService';
 import './mainThreadWindow';
 import './mainThreadWorkspace';
 

src/vs/workbench/api/electron-browser/mainThreadLogService.ts

@@ -5,20 +5,20 @@
 
 'use strict';
 
-import { IExtHostContext } from '../node/extHost.protocol';
 import { extHostCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { ILogService } from 'vs/platform/log/common/log';
 import { Disposable } from 'vs/base/common/lifecycle';
+import { IExtHostContext, ExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
 
 @extHostCustomer
-export class MainThreadLogLevelManagementChannel extends Disposable {
+export class MainThreadLogService extends Disposable {
 
 	constructor(
 		extHostContext: IExtHostContext,
 		@ILogService logService: ILogService,
 	) {
 		super();
-		// this._register(logService.onDidChangeLogLevel(level => extHostContext.getProxy(ExtHostContext.ExtHostLogService).$setLogLevel(level)));
+		this._register(logService.onDidChangeLogLevel(level => extHostContext.getProxy(ExtHostContext.ExtHostLogService).$setLevel(level)));
 	}
 
 }

src/vs/workbench/api/node/extHost.api.impl.ts

@@ -55,8 +55,8 @@ import { ExtHostDecorations } from 'vs/workbench/api/node/extHostDecorations';
 import { toGlobPattern, toLanguageSelector } from 'vs/workbench/api/node/extHostTypeConverters';
 import { ExtensionActivatedByAPI } from 'vs/workbench/api/node/extHostExtensionActivator';
 import { isFalsyOrEmpty } from 'vs/base/common/arrays';
-import { ILogService } from 'vs/platform/log/common/log';
 import { OverviewRulerLane } from 'vs/editor/common/model';
+import { ExtHostLogService } from 'vs/workbench/api/node/extHostLogService';
 
 export interface IExtensionApiFactory {
 	(extension: IExtensionDescription): typeof vscode;
@@ -89,18 +89,19 @@ export function createApiFactory(
 	extHostWorkspace: ExtHostWorkspace,
 	extHostConfiguration: ExtHostConfiguration,
 	extensionService: ExtHostExtensionService,
-	logService: ILogService
+	extHostLogService: ExtHostLogService
 ): IExtensionApiFactory {
 
 	// Addressable instances
+	rpcProtocol.set(ExtHostContext.ExtHostLogService, extHostLogService);
 	const extHostHeapService = rpcProtocol.set(ExtHostContext.ExtHostHeapService, new ExtHostHeapService());
 	const extHostDecorations = rpcProtocol.set(ExtHostContext.ExtHostDecorations, new ExtHostDecorations(rpcProtocol));
 	const extHostDocumentsAndEditors = rpcProtocol.set(ExtHostContext.ExtHostDocumentsAndEditors, new ExtHostDocumentsAndEditors(rpcProtocol));
 	const extHostDocuments = rpcProtocol.set(ExtHostContext.ExtHostDocuments, new ExtHostDocuments(rpcProtocol, extHostDocumentsAndEditors));
 	const extHostDocumentContentProviders = rpcProtocol.set(ExtHostContext.ExtHostDocumentContentProviders, new ExtHostDocumentContentProvider(rpcProtocol, extHostDocumentsAndEditors));
-	const extHostDocumentSaveParticipant = rpcProtocol.set(ExtHostContext.ExtHostDocumentSaveParticipant, new ExtHostDocumentSaveParticipant(logService, extHostDocuments, rpcProtocol.getProxy(MainContext.MainThreadEditors)));
+	const extHostDocumentSaveParticipant = rpcProtocol.set(ExtHostContext.ExtHostDocumentSaveParticipant, new ExtHostDocumentSaveParticipant(extHostLogService, extHostDocuments, rpcProtocol.getProxy(MainContext.MainThreadEditors)));
 	const extHostEditors = rpcProtocol.set(ExtHostContext.ExtHostEditors, new ExtHostEditors(rpcProtocol, extHostDocumentsAndEditors));
-	const extHostCommands = rpcProtocol.set(ExtHostContext.ExtHostCommands, new ExtHostCommands(rpcProtocol, extHostHeapService, logService));
+	const extHostCommands = rpcProtocol.set(ExtHostContext.ExtHostCommands, new ExtHostCommands(rpcProtocol, extHostHeapService, extHostLogService));
 	const extHostTreeViews = rpcProtocol.set(ExtHostContext.ExtHostTreeViews, new ExtHostTreeViews(rpcProtocol.getProxy(MainContext.MainThreadTreeViews), extHostCommands));
 	rpcProtocol.set(ExtHostContext.ExtHostWorkspace, extHostWorkspace);
 	const extHostDebugService = rpcProtocol.set(ExtHostContext.ExtHostDebugService, new ExtHostDebugService(rpcProtocol, extHostWorkspace));
@@ -111,7 +112,7 @@ export function createApiFactory(
 	const extHostFileSystemEvent = rpcProtocol.set(ExtHostContext.ExtHostFileSystemEventService, new ExtHostFileSystemEventService());
 	const extHostQuickOpen = rpcProtocol.set(ExtHostContext.ExtHostQuickOpen, new ExtHostQuickOpen(rpcProtocol, extHostWorkspace, extHostCommands));
 	const extHostTerminalService = rpcProtocol.set(ExtHostContext.ExtHostTerminalService, new ExtHostTerminalService(rpcProtocol));
-	const extHostSCM = rpcProtocol.set(ExtHostContext.ExtHostSCM, new ExtHostSCM(rpcProtocol, extHostCommands, logService));
+	const extHostSCM = rpcProtocol.set(ExtHostContext.ExtHostSCM, new ExtHostSCM(rpcProtocol, extHostCommands, extHostLogService));
 	const extHostTask = rpcProtocol.set(ExtHostContext.ExtHostTask, new ExtHostTask(rpcProtocol, extHostWorkspace));
 	const extHostWindow = rpcProtocol.set(ExtHostContext.ExtHostWindow, new ExtHostWindow(rpcProtocol));
 	rpcProtocol.set(ExtHostContext.ExtHostExtensionService, extensionService);

src/vs/workbench/api/node/extHost.protocol.ts

@@ -746,7 +746,7 @@ export interface ExtHostWindowShape {
 }
 
 export interface ExtHostLogServiceShape {
-	$setLogLevel(level: LogLevel);
+	$setLevel(level: LogLevel);
 }
 
 // --- proxy identifiers
@@ -799,7 +799,7 @@ export const ExtHostContext = {
 	ExtHostLanguageFeatures: createExtId<ExtHostLanguageFeaturesShape>('ExtHostLanguageFeatures'),
 	ExtHostQuickOpen: createExtId<ExtHostQuickOpenShape>('ExtHostQuickOpen'),
 	ExtHostExtensionService: createExtId<ExtHostExtensionServiceShape>('ExtHostExtensionService'),
-	// ExtHostLogService: createExtId<ExtHostLogServiceShape>('ExtHostLogService'),
+	ExtHostLogService: createExtId<ExtHostLogServiceShape>('ExtHostLogService'),
 	ExtHostTerminalService: createExtId<ExtHostTerminalServiceShape>('ExtHostTerminalService'),
 	ExtHostSCM: createExtId<ExtHostSCMShape>('ExtHostSCM'),
 	ExtHostTask: createExtId<ExtHostTaskShape>('ExtHostTask', ProxyType.CustomMarshaller),

src/vs/workbench/api/node/extHostExtensionService.ts

@@ -128,7 +128,6 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 	private readonly _storage: ExtHostStorage;
 	private readonly _storagePath: ExtensionStoragePath;
 	private readonly _proxy: MainThreadExtensionServiceShape;
-	private readonly _logService: ILogService;
 	private readonly _extHostLogService: ExtHostLogService;
 	private _activator: ExtensionsActivator;
 	private _extensionPathIndex: TPromise<TernarySearchTree<IExtensionDescription>>;
@@ -139,21 +138,20 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		extHostContext: IExtHostContext,
 		extHostWorkspace: ExtHostWorkspace,
 		extHostConfiguration: ExtHostConfiguration,
-		logService: ILogService,
+		extHostLogService: ExtHostLogService,
 		environmentService: IEnvironmentService
 	) {
 		this._barrier = new Barrier();
 		this._registry = new ExtensionDescriptionRegistry(initData.extensions);
-		this._logService = logService;
+		this._extHostLogService = extHostLogService;
 		this._mainThreadTelemetry = extHostContext.getProxy(MainContext.MainThreadTelemetry);
 		this._storage = new ExtHostStorage(extHostContext);
 		this._storagePath = new ExtensionStoragePath(initData.workspace, initData.environment);
 		this._proxy = extHostContext.getProxy(MainContext.MainThreadExtensionService);
 		this._activator = null;
-		this._extHostLogService = new ExtHostLogService(environmentService, this._logService);
 
 		// initialize API first (i.e. do not release barrier until the API is initialized)
-		const apiFactory = createApiFactory(initData, extHostContext, extHostWorkspace, extHostConfiguration, this, logService);
+		const apiFactory = createApiFactory(initData, extHostContext, extHostWorkspace, extHostConfiguration, this, this._extHostLogService);
 
 		initializeExtensionApi(this, apiFactory).then(() => {
 
@@ -314,14 +312,14 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 			return TPromise.as(new EmptyExtension(ExtensionActivationTimes.NONE));
 		}
 
-		this._logService.info(`ExtensionService#_doActivateExtension ${extensionDescription.id} ${JSON.stringify(reason)}`);
+		this._extHostLogService.info(`ExtensionService#_doActivateExtension ${extensionDescription.id} ${JSON.stringify(reason)}`);
 
 		const activationTimesBuilder = new ExtensionActivationTimesBuilder(reason.startup);
 		return TPromise.join<any>([
-			loadCommonJSModule(this._logService, extensionDescription.main, activationTimesBuilder),
+			loadCommonJSModule(this._extHostLogService, extensionDescription.main, activationTimesBuilder),
 			this._loadExtensionContext(extensionDescription)
 		]).then(values => {
-			return ExtHostExtensionService._callActivate(this._logService, extensionDescription.id, <IExtensionModule>values[0], <IExtensionContext>values[1], activationTimesBuilder);
+			return ExtHostExtensionService._callActivate(this._extHostLogService, extensionDescription.id, <IExtensionModule>values[0], <IExtensionContext>values[1], activationTimesBuilder);
 		}, (errors: any[]) => {
 			// Avoid failing with an array of errors, fail with a single error
 			if (errors[0]) {
@@ -339,7 +337,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		let globalState = new ExtensionMemento(extensionDescription.id, true, this._storage);
 		let workspaceState = new ExtensionMemento(extensionDescription.id, false, this._storage);
 
-		this._logService.trace(`ExtensionService#loadExtensionContext ${extensionDescription.id}`);
+		this._extHostLogService.trace(`ExtensionService#loadExtensionContext ${extensionDescription.id}`);
 		return TPromise.join([
 			globalState.whenReady,
 			workspaceState.whenReady,

src/vs/workbench/api/node/extHostLogService.ts

@@ -10,25 +10,26 @@ import { TPromise } from 'vs/base/common/winjs.base';
 import { mkdirp, dirExists } from 'vs/base/node/pfs';
 import Event from 'vs/base/common/event';
 import { LogLevel } from 'vs/workbench/api/node/extHostTypes';
-import { ILogService } from 'vs/platform/log/common/log';
+import { ILogService, DelegatedLogService } from 'vs/platform/log/common/log';
 import { createSpdLogService } from 'vs/platform/log/node/spdlogService';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { memoize } from 'vs/base/common/decorators';
 import { ExtHostLogServiceShape } from 'vs/workbench/api/node/extHost.protocol';
-import { Disposable } from 'vs/base/common/lifecycle';
 
-export class ExtHostLogService extends Disposable implements ExtHostLogServiceShape {
+
+export class ExtHostLogService extends DelegatedLogService implements ILogService, ExtHostLogServiceShape {
+
 	private _loggers: Map<string, ExtHostLogger> = new Map();
 
 	constructor(
-		private _environmentService: IEnvironmentService,
-		private _logService: ILogService
+		windowId: number,
+		private _environmentService: IEnvironmentService
 	) {
-		super();
+		super(createSpdLogService(`exthost${windowId}`, _environmentService));
 	}
 
-	$setLogLevel(level: LogLevel) {
-		this._logService.setLevel(level);
+	$setLevel(level: LogLevel): void {
+		this.setLevel(level);
 	}
 
 	getExtLogger(extensionID: string): ExtHostLogger {
@@ -43,7 +44,7 @@ export class ExtHostLogService extends Disposable implements ExtHostLogServiceSh
 	private createLogger(extensionID: string): ExtHostLogger {
 		const logService = createSpdLogService(extensionID, this._environmentService, extensionID);
 		const logsDirPath = path.join(this._environmentService.logsPath, extensionID);
-		this._register(this._logService.onDidChangeLogLevel(level => logService.setLevel(level)));
+		this._register(this.onDidChangeLogLevel(level => logService.setLevel(level)));
 		return new ExtHostLogger(logService, logsDirPath);
 	}
 }

src/vs/workbench/node/extensionHostMain.ts

@@ -21,12 +21,11 @@ import * as watchdog from 'native-watchdog';
 import * as glob from 'vs/base/common/glob';
 import { ExtensionActivatedByEvent } from 'vs/workbench/api/node/extHostExtensionActivator';
 import { EnvironmentService } from 'vs/platform/environment/node/environmentService';
-import { createSpdLogService } from 'vs/platform/log/node/spdlogService';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
-import { ILogService } from 'vs/platform/log/common/log';
 import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
 import { RPCProtocol } from 'vs/workbench/services/extensions/node/rpcProtocol';
 import URI from 'vs/base/common/uri';
+import { ExtHostLogService } from 'vs/workbench/api/node/extHostLogService';
 
 // const nativeExit = process.exit.bind(process);
 function patchProcess(allowExit: boolean) {
@@ -78,7 +77,7 @@ export class ExtensionHostMain {
 	private _environment: IEnvironment;
 	private _extensionService: ExtHostExtensionService;
 	private _extHostConfiguration: ExtHostConfiguration;
-	private _logService: ILogService;
+	private _extHostLogService: ExtHostLogService;
 	private disposables: IDisposable[] = [];
 
 	constructor(protocol: IMessagePassingProtocol, initData: IInitData) {
@@ -92,14 +91,14 @@ export class ExtensionHostMain {
 		const rpcProtocol = new RPCProtocol(protocol);
 		const extHostWorkspace = new ExtHostWorkspace(rpcProtocol, initData.workspace);
 		const environmentService = new EnvironmentService(initData.args, initData.execPath);
-		this._logService = createSpdLogService(`exthost${initData.windowId}`, environmentService);
-		this.disposables.push(this._logService);
+		this._extHostLogService = new ExtHostLogService(initData.windowId, environmentService);
+		this.disposables.push(this._extHostLogService);
 
-		this._logService.info('extension host started');
-		this._logService.trace('initData', initData);
+		this._extHostLogService.info('extension host started');
+		this._extHostLogService.trace('initData', initData);
 
 		this._extHostConfiguration = new ExtHostConfiguration(rpcProtocol.getProxy(MainContext.MainThreadConfiguration), extHostWorkspace, initData.configuration);
-		this._extensionService = new ExtHostExtensionService(initData, rpcProtocol, extHostWorkspace, this._extHostConfiguration, this._logService, environmentService);
+		this._extensionService = new ExtHostExtensionService(initData, rpcProtocol, extHostWorkspace, this._extHostConfiguration, this._extHostLogService, environmentService);
 
 		// error forwarding and stack trace scanning
 		const extensionErrors = new WeakMap<Error, IExtensionDescription>();
@@ -143,7 +142,7 @@ export class ExtensionHostMain {
 			.then(() => this.handleEagerExtensions())
 			.then(() => this.handleExtensionTests())
 			.then(() => {
-				this._logService.info(`eager extensions activated`);
+				this._extHostLogService.info(`eager extensions activated`);
 			});
 	}