@theia/core 1.73.0-next.2 → 1.73.0-next.24

package/src/browser/shell/application-shell.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject, optional, postConstruct } from 'inversify';
+import { injectable, inject, optional, postConstruct, named } from 'inversify';
 import { ArrayExt, find, toArray, each } from '@lumino/algorithm';
 import {
     BoxLayout, BoxPanel, DockLayout, DockPanel, FocusTracker, Layout, Panel, SplitLayout,
@@ -46,6 +46,7 @@ import { OpenerService } from '../opener-service';
 import { PreviewableWidget } from '../widgets/previewable-widget';
 import { WindowService } from '../window/window-service';
 import { TheiaSplitPanel } from './theia-split-panel';
+import { ILogger } from '../../common/logger';
 
 /** The class name added to ApplicationShell instances. */
 export const APPLICATION_SHELL_CLASS = 'theia-ApplicationShell';
@@ -242,6 +243,9 @@ export class ApplicationShell extends Widget {
     @inject(UntitledResourceResolver)
     protected readonly untitledResourceResolver: UntitledResourceResolver;
 
+    @inject(ILogger) @named('core:ApplicationShell')
+    protected readonly logger: ILogger;
+
     protected readonly onDidAddWidgetEmitter = new Emitter<Widget>();
     readonly onDidAddWidget = this.onDidAddWidgetEmitter.event;
     protected fireDidAddWidget(widget: Widget): void {
@@ -595,7 +599,7 @@ export class ApplicationShell extends Widget {
                 const opener = await this.openerService.getOpener(fileUri);
                 opener.open(fileUri);
             } catch (e) {
-                console.info(`no opener found for '${fileUri}'`);
+                this.logger.info(`no opener found for '${fileUri}'`);
             }
         };
 
@@ -975,7 +979,7 @@ export class ApplicationShell extends Widget {
      */
     async addWidget(widget: Widget, options?: Readonly<ApplicationShell.WidgetOptions>): Promise<void> {
         if (!widget.id) {
-            console.error('Widgets added to the application shell must have a unique id property.');
+            this.logger.error('Widgets added to the application shell must have a unique id property.');
             return;
         }
         const { area, addOptions } = this.getInsertionOptions(options);
@@ -1430,7 +1434,7 @@ export class ApplicationShell extends Widget {
             if (delta < this.activationTimeout) {
                 request = setTimeout(step, 0);
             } else {
-                console.warn(`Widget was activated, but did not accept focus after ${this.activationTimeout}ms: ${widget.id}`);
+                this.logger.warn(`Widget was activated, but did not accept focus after ${this.activationTimeout}ms: ${widget.id}`);
             }
         };
         let request = setTimeout(step, 0);

package/src/browser/tree/tree-container.spec.ts

@@ -19,6 +19,8 @@ import { Container } from 'inversify';
 import { createTreeContainer, isTreeServices } from './tree-container';
 import { TreeSearch } from './tree-search';
 import { defaultTreeProps, TreeProps } from './tree-widget';
+import { ILogger } from '../../common/logger';
+import { MockLogger } from '../../common/test/mock-logger';
 
 describe('TreeContainer', () => {
     describe('IsTreeServices should accurately distinguish TreeProps from TreeContainerProps', () => {
@@ -33,11 +35,15 @@ describe('TreeContainer', () => {
         const nonDefault = { search: !defaultTreeProps.search, contextMenu: ['no-default-for-this'] };
         it('should use props passed in as just props', () => {
             const parent = new Container();
+            parent.bind(ILogger).to(MockLogger).inSingletonScope();
+
             const child = createTreeContainer(parent, nonDefault);
             assert.deepStrictEqual(child.get(TreeProps), { ...defaultTreeProps, ...nonDefault });
         });
         it('should use props passed in as part of TreeContainerProps', () => {
             const parent = new Container();
+            parent.bind(ILogger).to(MockLogger).inSingletonScope();
+
             const child = createTreeContainer(parent, { props: nonDefault });
             assert.deepStrictEqual(child.get(TreeProps), { ...defaultTreeProps, ...nonDefault });
         });

package/src/browser/tree/tree.ts

@@ -14,13 +14,14 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from 'inversify';
+import { injectable, inject, named } from 'inversify';
 import { Event, Emitter, WaitUntilEvent } from '../../common/event';
 import { Disposable, DisposableCollection } from '../../common/disposable';
 import { CancellationToken, CancellationTokenSource } from '../../common/cancellation';
 import { timeout } from '../../common/promise-util';
 import { isObject, Mutable } from '../../common';
 import { AccessibilityInformation } from '../../common/accessibility';
+import { ILogger } from '../../common/logger';
 
 export const Tree = Symbol('Tree');
 
@@ -250,6 +251,9 @@ export namespace CompositeTreeNode {
 @injectable()
 export class TreeImpl implements Tree {
 
+    @inject(ILogger) @named('core:TreeImpl')
+    protected readonly logger: ILogger;
+
     protected _root: TreeNode | undefined;
     protected readonly onChangedEmitter = new Emitter<void>();
     protected readonly onNodeRefreshedEmitter = new Emitter<CompositeTreeNode & WaitUntilEvent>();
@@ -344,7 +348,7 @@ export class TreeImpl implements Tree {
     protected async setChildren(parent: CompositeTreeNode, children: TreeNode[]): Promise<CompositeTreeNode | undefined> {
         const root = this.getRootNode(parent);
         if (this.nodes[root.id] && this.nodes[root.id] !== root) {
-            console.error(`Child node '${parent.id}' does not belong to this '${root.id}' tree.`);
+            this.logger.error(`Child node '${parent.id}' does not belong to this '${root.id}' tree.`);
             return undefined;
         }
         this.removeNode(parent);

package/src/browser/window/default-window-service.spec.ts

@@ -15,11 +15,12 @@
 // *****************************************************************************
 
 import { Container } from 'inversify';
-import { ContributionProvider } from '../../common';
+import { ContributionProvider, ILogger } from '../../common';
 import { CorePreferences } from '../../common/core-preferences';
 import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { DefaultWindowService } from './default-window-service';
 import assert = require('assert');
+import { MockLogger } from '../../common/test/mock-logger';
 
 describe('DefaultWindowService', () => {
     class TestFrontendApplicationContribution implements FrontendApplicationContribution {
@@ -42,6 +43,7 @@ describe('DefaultWindowService', () => {
             .toConstantValue({
                 'application.confirmExit': confirmExit,
             });
+        container.bind(ILogger).to(MockLogger).inSingletonScope();
         return container.get(DefaultWindowService);
     }
     it('onWillStop should be called on every contribution (never)', () => {

package/src/browser/window/default-window-service.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { inject, injectable, named } from 'inversify';
-import { Event, Emitter } from '../../common';
+import { Event, Emitter, ILogger } from '../../common';
 import { CorePreferences } from '../../common/core-preferences';
 import { ContributionProvider } from '../../common/contribution-provider';
 import { FrontendApplicationContribution, OnWillStopAction } from '../frontend-application-contribution';
@@ -43,6 +43,9 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
     @named(FrontendApplicationContribution)
     protected readonly contributions: ContributionProvider<FrontendApplicationContribution>;
 
+    @inject(ILogger) @named('core:DefaultWindowService')
+    protected readonly logger: ILogger;
+
     onStart(app: FrontendApplication): void {
         this.frontendApplication = app;
         this.registerUnloadListeners();
@@ -114,7 +117,7 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
             return true;
         }
         const preparedValues = await Promise.all(vetoes.map(e => e.prepare?.(stopReason)));
-        console.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
+        this.logger.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
         for (let i = 0; i < vetoes.length; i++) {
             try {
                 const result = await vetoes[i].action(preparedValues[i], stopReason);
@@ -122,10 +125,10 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
                     return false;
                 }
             } catch (e) {
-                console.error(e);
+                this.logger.error(e);
             }
         }
-        console.debug('OnWillStop actions resolved; allowing shutdown');
+        this.logger.debug('OnWillStop actions resolved; allowing shutdown');
         this.allowVetoes = false;
         return true;
     }
@@ -145,10 +148,10 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
         const vetoes = this.collectContributionUnloadVetoes();
         if (vetoes.length) {
             // In the browser, we don't call the functions because this has to finish in a single tick, so we treat any desired action as a veto.
-            console.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
+            this.logger.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
             return this.preventUnload(event);
         }
-        console.debug('Shutdown will proceed.');
+        this.logger.debug('Shutdown will proceed.');
     }
 
     /**

package/src/browser-only/messaging/frontend-only-service-connection-provider.ts

@@ -14,8 +14,9 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { Event, RpcProxy, Channel, RpcProxyFactory, Emitter } from '../../common';
-import { injectable } from 'inversify';
+import { injectable, inject, named } from 'inversify';
 import { ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
+import { ILogger } from '../../common/logger';
 import { ConnectionSource } from '../../browser/messaging/connection-source';
 
 @injectable()
@@ -25,15 +26,19 @@ export class FrontendOnlyConnectionSource implements ConnectionSource {
 
 @injectable()
 export class FrontendOnlyServiceConnectionProvider extends ServiceConnectionProvider {
+
+    @inject(ILogger) @named('core:FrontendOnlyServiceConnectionProvider')
+    protected readonly logger: ILogger;
+
     onSocketDidOpen = Event.None;
     onSocketDidClose = Event.None;
     onIncomingMessageActivity = Event.None;
     override createProxy<T extends object>(path: unknown, target?: unknown): RpcProxy<T> {
-        console.debug(`[Frontend-Only Fallback] Created proxy connection for ${path}`);
+        this.logger.debug(`[Frontend-Only Fallback] Created proxy connection for ${path}`);
         const factory = target instanceof RpcProxyFactory ? target : new RpcProxyFactory<T>(target);
         return factory.createProxy();
     }
     override listen(path: string, handler: ServiceConnectionProvider.ConnectionHandler, reconnect: boolean): void {
-        console.debug('[Frontend-Only Fallback] Listen to websocket connection requested');
+        this.logger.debug('[Frontend-Only Fallback] Listen to websocket connection requested');
     }
 }

package/src/common/command.ts

@@ -21,6 +21,7 @@ import { ContributionProvider } from './contribution-provider';
 import { nls } from './nls';
 import debounce = require('p-debounce');
 import { isObject } from './types';
+import { ILogger } from './logger';
 
 /**
  * A command is a unique identifier of a function
@@ -190,6 +191,9 @@ export interface CommandService {
 @injectable()
 export class CommandRegistry implements CommandService {
 
+    @inject(ILogger) @named('core:CommandRegistry')
+    protected readonly logger: ILogger;
+
     protected readonly _commands: { [id: string]: Command } = {};
     protected readonly _handlers: { [id: string]: CommandHandler[] } = {};
 
@@ -232,7 +236,7 @@ export class CommandRegistry implements CommandService {
      */
     registerCommand(command: Command, handler?: CommandHandler): Disposable {
         if (this._commands[command.id]) {
-            console.warn(`A command ${command.id} is already registered.`);
+            this.logger.warn(`A command ${command.id} is already registered.`);
             return Disposable.NULL;
         }
         const toDispose = new DisposableCollection(this.doRegisterCommand(command));
@@ -363,7 +367,7 @@ export class CommandRegistry implements CommandService {
                         return handler;
                     }
                 } catch (error) {
-                    console.error(error);
+                    this.logger.error(error);
                 }
             }
         }
@@ -383,7 +387,7 @@ export class CommandRegistry implements CommandService {
                         return handler;
                     }
                 } catch (error) {
-                    console.error(error);
+                    this.logger.error(error);
                 }
             }
         }
@@ -403,7 +407,7 @@ export class CommandRegistry implements CommandService {
                         return handler;
                     }
                 } catch (error) {
-                    console.error(error);
+                    this.logger.error(error);
                 }
             }
         }

package/src/electron-main/electron-main-application.ts

@@ -45,6 +45,7 @@ import { StopReason } from '../common/frontend-application-state';
 import { dynamicRequire } from '../node/dynamic-require';
 import { ThemeMode } from '../common/theme';
 import { backendGlobal } from '../node/backend-global';
+import { ILogger } from '../common/logger';
 
 export { ElectronMainApplicationGlobals };
 
@@ -174,6 +175,9 @@ export class ElectronMainApplication {
     @inject(TheiaElectronWindowFactory)
     protected readonly windowFactory: TheiaElectronWindowFactory;
 
+    @inject(ILogger) @named('core:ElectronMainApplication')
+    protected readonly logger: ILogger;
+
     @inject(Stopwatch)
     protected readonly stopwatch: Stopwatch;
 
@@ -231,7 +235,7 @@ export class ElectronMainApplication {
                     .positional('file', { type: 'string' }),
                 async args => {
                     if (args.electronUserData) {
-                        console.info(`using electron user data area : '${args.electronUserData}'`);
+                        this.logger.info(`using electron user data area : '${args.electronUserData}'`);
                         await fs.mkdir(args.electronUserData, { recursive: true });
                         app.setPath('userData', args.electronUserData);
                     }
@@ -298,7 +302,7 @@ export class ElectronMainApplication {
         if (browserWindow) {
             this.saveWindowState(browserWindow);
         } else {
-            console.warn(`no BrowserWindow with id: ${webContents.id}`);
+            this.logger.warn(`no BrowserWindow with id: ${webContents.id}`);
         }
     }
 
@@ -365,7 +369,7 @@ export class ElectronMainApplication {
 
     protected async configureAndShowSplashScreen(mainWindow: BrowserWindow): Promise<BrowserWindow> {
         const splashScreenOptions = this.getSplashScreenOptions()!;
-        console.debug('SplashScreen options', splashScreenOptions);
+        this.logger.debug('SplashScreen options', splashScreenOptions);
 
         const splashScreenBounds = await this.determineSplashScreenBounds(mainWindow.getBounds());
         const splashScreenWindow = new BrowserWindow({
@@ -394,6 +398,8 @@ export class ElectronMainApplication {
         const cancelTokenSource = new CancellationTokenSource();
         const minTime = timeout(splashScreenOptions.minDuration ?? 0, cancelTokenSource.token);
         const maxTime = timeout(splashScreenOptions.maxDuration ?? 30000, cancelTokenSource.token);
+        // Swallow rejections that occur when the cancellation token is cancelled after one of the timers wins.
+        const ignoreCancellation = () => { /* timer was cancelled, intentionally ignored */ };
 
         const showWindowAndCloseSplashScreen = () => {
             cancelTokenSource.cancel();
@@ -404,10 +410,10 @@ export class ElectronMainApplication {
         };
         TheiaRendererAPI.onApplicationStateChanged(mainWindow.webContents, state => {
             if (state === 'ready') {
-                minTime.then(() => showWindowAndCloseSplashScreen());
+                minTime.then(() => showWindowAndCloseSplashScreen(), ignoreCancellation);
             }
         });
-        maxTime.then(() => showWindowAndCloseSplashScreen());
+        maxTime.then(() => showWindowAndCloseSplashScreen(), ignoreCancellation);
         return splashScreenWindow;
     }
 
@@ -556,7 +562,7 @@ export class ElectronMainApplication {
             try {
                 workspacePath = await fs.realpath(path.resolve(options.cwd, options.file));
             } catch {
-                console.error(`Could not resolve the workspace path. "${options.file}" is not a valid 'file' option. Falling back to the default workspace location.`);
+                this.logger.error(`Could not resolve the workspace path. "${options.file}" is not a valid 'file' option. Falling back to the default workspace location.`);
             }
         }
         if (workspacePath !== undefined) {
@@ -634,13 +640,13 @@ export class ElectronMainApplication {
         // On Wayland, screen.getCursorScreenPoint() causes a native crash (SIGSEGV)
         // before any window is opened. Detect Wayland and use primary display instead.
         if (this.isWaylandSession()) {
-            console.debug('Running under Wayland, using primary display for new window.');
+            this.logger.debug('Running under Wayland, using primary display for new window.');
             return screen.getPrimaryDisplay();
         }
         try {
             return screen.getDisplayNearestPoint(screen.getCursorScreenPoint());
         } catch (error) {
-            console.warn('Failed to get cursor screen point, falling back to primary display.', error);
+            this.logger.warn('Failed to get cursor screen point, falling back to primary display.', error);
             return screen.getPrimaryDisplay();
         }
     }
@@ -711,7 +717,7 @@ export class ElectronMainApplication {
             };
             this.electronStore.set('windowstate', options);
         } catch (e) {
-            console.error('Error while saving window state:', e);
+            this.logger.error('Error while saving window state:', e);
         }
     }
 

package/src/electron-main/messaging/electron-messaging-contribution.ts

@@ -25,6 +25,7 @@ import { MessagingService } from '../../node';
 import { ElectronMessagingService } from './electron-messaging-service';
 import { ElectronConnectionHandler } from './electron-connection-handler';
 import { ElectronMainApplicationContribution } from '../electron-main-application';
+import { ILogger } from '../../common/logger';
 
 /**
  * This component replicates the role filled by `MessagingContribution` but for Electron.
@@ -42,6 +43,9 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
     @inject(ContributionProvider) @named(ElectronConnectionHandler)
     protected readonly connectionHandlers: ContributionProvider<ConnectionHandler>;
 
+    @inject(ILogger) @named('core:ElectronMessagingContribution')
+    protected readonly logger: ILogger;
+
     protected readonly channelHandlers = new ConnectionHandlers<Channel>();
 
     /**
@@ -76,7 +80,7 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
             const windowChannel = this.openChannels.get(sender.id) ?? this.createWindowChannel(sender);
             windowChannel.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(data));
         } catch (error) {
-            console.error('IPC: Failed to handle message', { error, data });
+            this.logger.error('IPC: Failed to handle message', { error, data });
         }
     }
 
@@ -88,8 +92,8 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
         multiplexer.onDidOpenChannel(openEvent => {
             const { channel, id } = openEvent;
             if (this.channelHandlers.route(id, channel)) {
-                console.debug(`Opening channel for service path '${id}'.`);
-                channel.onClose(() => console.debug(`Closing channel on service path '${id}'.`));
+                this.logger.debug(`Opening channel for service path '${id}'.`);
+                channel.onClose(() => this.logger.debug(`Closing channel on service path '${id}'.`));
             }
         });
         sender.once('did-navigate', () => this.deleteChannel(sender.id, 'Window was refreshed'));

package/src/electron-node/request/electron-backend-request-service.ts

@@ -14,15 +14,19 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { decorate, injectable } from 'inversify';
+import { decorate, injectable, inject, named } from 'inversify';
 import { NodeRequestOptions, NodeRequestService } from '@theia/request/lib/node-request-service';
 import { ElectronSecurityToken } from '../../electron-common/electron-token';
+import { ILogger } from '../../common';
 
 decorate(injectable(), NodeRequestService);
 
 @injectable()
 export class ElectronBackendRequestService extends NodeRequestService {
 
+    @inject(ILogger) @named('core:ElectronBackendRequestService')
+    protected readonly logger: ILogger;
+
     override async getProxyUrl(url: string): Promise<string | undefined> {
         if (this.proxyUrl) {
             return this.proxyUrl;
@@ -34,7 +38,7 @@ export class ElectronBackendRequestService extends NodeRequestService {
                 return this.buildProxyUrl(url, proxyHost);
             }
         } catch (e) {
-            console.error('Could not resolve electron proxy.', e);
+            this.logger.error('Could not resolve electron proxy.', e);
         }
         return super.getProxyUrl(url);
     }

package/src/electron-node/token/electron-token-backend-contribution.ts

@@ -15,9 +15,10 @@
 // *****************************************************************************
 
 import express = require('express');
-import { injectable, inject } from 'inversify';
+import { injectable, inject, named } from 'inversify';
 import { BackendApplicationContribution } from '../../node';
 import { ElectronTokenValidator } from './electron-token-validator';
+import { ILogger } from '../../common/logger';
 
 /**
  * This component contributes an Express middleware that will refuse all
@@ -26,6 +27,9 @@ import { ElectronTokenValidator } from './electron-token-validator';
 @injectable()
 export class ElectronTokenBackendContribution implements BackendApplicationContribution {
 
+    @inject(ILogger) @named('core:ElectronTokenBackendContribution')
+    protected readonly logger: ILogger;
+
     @inject(ElectronTokenValidator)
     protected readonly tokenValidator: ElectronTokenValidator;
 
@@ -40,7 +44,7 @@ export class ElectronTokenBackendContribution implements BackendApplicationContr
         if (this.tokenValidator.allowRequest(req)) {
             next();
         } else {
-            console.error(`refused an http request: ${req.connection.remoteAddress}`);
+            this.logger.error(`refused an http request: ${req.connection.remoteAddress}`);
             res.sendStatus(403);
         }
     }

package/src/electron-node/token/electron-token-validator.ts

@@ -17,10 +17,11 @@
 import * as http from 'http';
 import * as cookie from 'cookie';
 import * as crypto from 'crypto';
-import { injectable, postConstruct } from 'inversify';
+import { injectable, postConstruct, inject, named } from 'inversify';
 import { isObject, isString, MaybePromise } from '../../common';
 import { ElectronSecurityToken } from '../../electron-common/electron-token';
 import { WsRequestValidatorContribution } from '../../node/ws-request-validators';
+import { ILogger } from '../../common/logger';
 
 /**
  * On Electron, we want to make sure that only Electron's browser-windows access the backend services.
@@ -28,6 +29,9 @@ import { WsRequestValidatorContribution } from '../../node/ws-request-validators
 @injectable()
 export class ElectronTokenValidator implements WsRequestValidatorContribution {
 
+    @inject(ILogger) @named('core:ElectronTokenValidator')
+    protected readonly logger: ILogger;
+
     protected electronSecurityToken?: ElectronSecurityToken;
 
     @postConstruct()
@@ -70,7 +74,7 @@ export class ElectronTokenValidator implements WsRequestValidatorContribution {
                 const expected = Buffer.from(this.electronSecurityToken!.value, 'utf8');
                 return received.byteLength === expected.byteLength && crypto.timingSafeEqual(received, expected);
             } catch (error) {
-                console.error(error);
+                this.logger.error(error);
             }
         }
         return false;

package/src/node/backend-application.spec.ts

@@ -19,7 +19,6 @@ import * as sinon from 'sinon';
 import { Container, ContainerModule, injectable, preDestroy } from 'inversify';
 import { bindContributionProvider, ILogger, Stopwatch } from '../common';
 import { Deferred } from '../common/promise-util';
-import { MockLogger } from '../common/test/mock-logger';
 import { NodeStopwatch } from './performance/node-stopwatch';
 import { ProcessUtils } from './process-utils';
 import {
@@ -29,6 +28,7 @@ import {
     RootContainer
 } from './backend-application';
 import { CliContribution } from './cli';
+import { MockLogger } from '../common/test/mock-logger';
 
 /**
  * Test subclass that exposes the protected `gracefulShutdown` for direct testing.
@@ -82,7 +82,6 @@ describe('BackendApplication', () => {
         const container = new Container();
 
         container.bind(RootContainer).toConstantValue(container);
-
         container.bind(ILogger).to(MockLogger).inSingletonScope();
         container.bind(Stopwatch).to(NodeStopwatch).inSingletonScope();
         container.bind(ProcessUtils).toSelf().inSingletonScope();
@@ -242,7 +241,8 @@ describe('BackendApplication', () => {
             container.bind(BackendApplicationContribution).toConstantValue({
                 onStop: () => { secondRan = true; }
             });
-            const errorStub = sandbox.stub(console, 'error');
+            const mockLogger = container.get(ILogger) as ILogger;
+            const errorStub = sandbox.stub(mockLogger, 'error');
 
             const app = container.get(TestBackendApplication);
             await app.invokeGracefulShutdown();

package/src/node/backend-application.ts

@@ -28,6 +28,7 @@ import { Deferred, timeoutReject } from '../common/promise-util';
 import { environment } from '../common/index';
 import { AddressInfo } from 'net';
 import { ProcessUtils } from './process-utils';
+import { ILogger } from '../common/logger';
 
 /**
  * The path to the application project directory. This is the directory where the application code is located.
@@ -180,6 +181,9 @@ export class BackendApplication {
     @inject(Stopwatch)
     protected readonly stopwatch: Stopwatch;
 
+    @inject(ILogger) @named('core:BackendApplication')
+    protected readonly logger: ILogger;
+
     @inject(RootContainer)
     protected readonly rootContainer: interfaces.Container;
 
@@ -201,7 +205,7 @@ export class BackendApplication {
         // Workaround for Electron not installing a handler to ignore SIGPIPE error
         // (https://github.com/electron/electron/issues/13254)
         process.on('SIGPIPE', () => {
-            console.error(new Error('Unexpected SIGPIPE'));
+            this.logger.error(new Error('Unexpected SIGPIPE'));
         });
 
         // Handles normal process termination.
@@ -221,7 +225,7 @@ export class BackendApplication {
                     await this.measureContribution(contribution, 'initialize',
                         () => contribution.initialize!());
                 } catch (error) {
-                    console.error('Could not initialize contribution', error);
+                    this.logger.error('Could not initialize contribution', error);
                 }
             }
         }));
@@ -258,11 +262,11 @@ export class BackendApplication {
                     await this.measureContribution(contribution, 'configure',
                         () => contribution.configure!(this.app));
                 } catch (error) {
-                    console.error('Could not configure contribution', error);
+                    this.logger.error('Could not configure contribution', error);
                 }
             }
         }));
-        console.info('configured all backend app contributions');
+        this.logger.info('configured all backend app contributions');
     }
 
     use(...handlers: express.Handler[]): void {
@@ -297,14 +301,14 @@ export class BackendApplication {
             try {
                 key = await fs.readFile(this.cliParams.certkey as string);
             } catch (err) {
-                console.error("Can't read certificate key");
+                this.logger.error("Can't read certificate key");
                 throw err;
             }
 
             try {
                 cert = await fs.readFile(this.cliParams.cert as string);
             } catch (err) {
-                console.error("Can't read certificate");
+                this.logger.error("Can't read certificate");
                 throw err;
             }
             server = https.createServer({ key, cert }, this.app);
@@ -323,7 +327,7 @@ export class BackendApplication {
             // address should be defined at this point
             const address = server.address()!;
             const url = typeof address === 'string' ? address : this.getHttpUrl(address, this.cliParams.ssl);
-            console.info(`Theia app listening on ${url}.`);
+            this.logger.info(`Theia app listening on ${url}.`);
             deferred.resolve(server);
         });
 
@@ -336,7 +340,7 @@ export class BackendApplication {
                     await this.measureContribution(contribution, 'onStart',
                         () => contribution.onStart!(server));
                 } catch (error) {
-                    console.error('Could not start contribution', error);
+                    this.logger.error('Could not start contribution', error);
                 }
             }
         }
@@ -415,7 +419,7 @@ export class BackendApplication {
                 try {
                     await contrib.onStop(this.app);
                 } catch (error) {
-                    console.error('Could not stop contribution', error);
+                    this.logger.error('Could not stop contribution', error);
                 }
             }
         }));
@@ -466,9 +470,9 @@ export class BackendApplication {
 
     protected handleUncaughtError(error: Error): void {
         if (error) {
-            console.error('Uncaught Exception: ', error.toString());
+            this.logger.error('Uncaught Exception: ', error.toString());
             if (error.stack) {
-                console.error(error.stack);
+                this.logger.error(error.stack);
             }
         }
     }