@theia/core 1.75.0-next.8 → 1.75.0

package/src/common/message-service-protocol.ts

@@ -14,9 +14,10 @@
 // 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 { CancellationToken } from './cancellation';
 import { nls } from './nls';
+import { ILogger } from './logger';
 
 export const messageServicePath = '/services/messageService';
 
@@ -115,6 +116,9 @@ export interface ProgressUpdate {
 @injectable()
 export class MessageClient {
 
+    @inject(ILogger) @named('core:MessageClient')
+    protected readonly logger: ILogger;
+
     /**
      * Show a message of the given type and possible actions to the user.
      * Resolve to a chosen action.
@@ -123,7 +127,7 @@ export class MessageClient {
      * To be implemented by an extension, e.g. by the messages extension.
      */
     showMessage(message: Message): Promise<string | undefined> {
-        console.info(message.text);
+        this.logger.info(message.text);
         return Promise.resolve(undefined);
     }
 
@@ -133,7 +137,7 @@ export class MessageClient {
      * To be implemented by an extension, e.g. by the messages extension.
      */
     showProgress(progressId: string, message: ProgressMessage, cancellationToken: CancellationToken): Promise<string | undefined> {
-        console.info(message.text);
+        this.logger.info(message.text);
         return Promise.resolve(undefined);
     }
 

package/src/common/performance/stopwatch.ts

@@ -16,7 +16,7 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { inject, injectable, unmanaged } from 'inversify';
+import { inject, injectable, unmanaged, named } from 'inversify';
 import { ILogger, LogLevel } from '../logger';
 import { MaybePromise } from '../types';
 import { Measurement, MeasurementOptions, MeasurementResult } from './measurement';
@@ -48,7 +48,7 @@ interface LogOptions extends MeasurementOptions {
 @injectable()
 export abstract class Stopwatch {
 
-    @inject(ILogger)
+    @inject(ILogger) @named('core:Stopwatch')
     protected readonly logger: ILogger;
 
     protected _storedMeasurements: MeasurementResult[] = [];

package/src/common/preferences/preference-schema-service.ts

@@ -24,6 +24,7 @@ import { PreferenceScope, ValidPreferenceScopes } from './preference-scope';
 import { PreferenceUtils } from './preference-provider';
 import { ContributionProvider } from '../contribution-provider';
 import { Deferred } from '../promise-util';
+import { ILogger } from '../logger';
 
 export const NO_OVERRIDE = {};
 export const OVERRIDE_PROPERTY = '\\[(.*)\\]$';
@@ -78,6 +79,9 @@ export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
     @inject(ContributionProvider) @named(PreferenceContribution)
     protected readonly preferenceContributions: ContributionProvider<PreferenceContribution>;
 
+    @inject(ILogger) @named('core:PreferenceSchemaServiceImpl')
+    protected readonly logger: ILogger;
+
     @postConstruct()
     protected init(): void {
         for (const scope of this.validScopes) {
@@ -128,7 +132,7 @@ export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
 
         for (const [key, property] of Object.entries(schema.properties)) {
             if (this.properties.has(key)) {
-                console.warn(`Property with id '${key}' already exists`);
+                this.logger.warn(`Property with id '${key}' already exists`);
                 continue;
             }
             this.pendingDefaultRegistrationWarnings?.delete(key);
@@ -210,14 +214,14 @@ export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
             this.setJSONSchemasProperty(key, updatedProperty);
             this.schemaChangedEmitter.fire();
         } else {
-            console.warn(`Trying to update non-existent property ${key}`);
+            this.logger.warn(`Trying to update non-existent property ${key}`);
         }
     }
 
     protected pendingDefaultRegistrationWarnings: Set<string> | undefined = new Set();
     protected logDefaultRegistrationWarnings(): void {
         if (this.pendingDefaultRegistrationWarnings?.size) {
-            console.warn('Default overrides registered for these keys, but preferences not registered', Array.from(this.pendingDefaultRegistrationWarnings));
+            this.logger.warn('Default overrides registered for these keys, but preferences not registered', Array.from(this.pendingDefaultRegistrationWarnings));
         }
         this.pendingDefaultRegistrationWarnings = undefined;
     }
@@ -226,7 +230,7 @@ export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
         if (this.pendingDefaultRegistrationWarnings) {
             this.pendingDefaultRegistrationWarnings.add(key);
         } else {
-            console.warn(`Trying to register default override for non-existent preference: ${key}`);
+            this.logger.warn(`Trying to register default override for non-existent preference: ${key}`);
         }
     }
 
@@ -236,7 +240,7 @@ export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
         if (!property) {
             this.logDefaultRegistrationWarning(key);
         } else if (!property.overridable && overrideIdentifier) {
-            console.warn(`Trying to register default override for identifier ${overrideIdentifier} for non-overridable preference: ${key}`);
+            this.logger.warn(`Trying to register default override for identifier ${overrideIdentifier} for non-overridable preference: ${key}`);
         }
 
         let overrides = this.defaultOverrides.get(key);

package/src/common/preferences/preference-service.ts

@@ -17,7 +17,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { JSONValue } from '@lumino/coreutils';
-import { inject, injectable, postConstruct } from 'inversify';
+import { inject, injectable, postConstruct, named } from 'inversify';
 import { Disposable, DisposableCollection } from '../disposable';
 import { Emitter, Event } from '../event';
 import { Deferred } from '../promise-util';
@@ -29,6 +29,7 @@ import { PreferenceScope } from './preference-scope';
 import { PreferenceConfigurations } from './preference-configurations';
 import { deepFreeze } from '../objects';
 import { unreachable } from '../types';
+import { ILogger } from '../logger';
 
 /**
  * Representation of a preference change. A preference value can be set to `undefined` for a specific scope.
@@ -296,6 +297,9 @@ export class PreferenceServiceImpl implements PreferenceService {
     @inject(PreferenceLanguageOverrideService)
     protected readonly preferenceOverrideService: PreferenceLanguageOverrideService;
 
+    @inject(ILogger) @named('core:PreferenceServiceImpl')
+    protected readonly logger: ILogger;
+
     protected readonly preferenceProviders = new Map<PreferenceScope, PreferenceProvider>();
 
     protected async initializeProviders(): Promise<void> {
@@ -309,7 +313,7 @@ export class PreferenceServiceImpl implements PreferenceService {
                     ));
                     await provider.ready;
                 } else {
-                    console.warn(`No preference provider bound for ${PreferenceScope[scope]}`);
+                    this.logger.warn(`No preference provider bound for ${PreferenceScope[scope]}`);
                 }
             }
             this._ready.resolve();

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

@@ -142,7 +142,8 @@ describe('BackendApplication', () => {
             const container = createTestContainer();
             const cleanupError = new Error('cleanup boom');
             sandbox.stub(container, 'unbindAllAsync').rejects(cleanupError);
-            const warnStub = sandbox.stub(console, 'warn');
+            const mockLogger = container.get(ILogger) as ILogger;
+            const warnStub = sandbox.stub(mockLogger, 'warn');
 
             const app = container.get(TestBackendApplication);
 
@@ -157,7 +158,8 @@ describe('BackendApplication', () => {
             const clock = sandbox.useFakeTimers();
             const container = createTestContainer();
             sandbox.stub(container, 'unbindAllAsync').returns(new Promise<void>(() => { /* never */ }));
-            const warnStub = sandbox.stub(console, 'warn');
+            const mockLogger = container.get(ILogger) as ILogger;
+            const warnStub = sandbox.stub(mockLogger, 'warn');
 
             const app = container.get(TestBackendApplication);
 
@@ -220,7 +222,8 @@ describe('BackendApplication', () => {
                 onStop: () => new Promise<void>(() => { /* never */ })
             });
             const unbindSpy = sandbox.spy(container, 'unbindAllAsync');
-            const warnStub = sandbox.stub(console, 'warn');
+            const mockLogger = container.get(ILogger) as ILogger;
+            const warnStub = sandbox.stub(mockLogger, 'warn');
 
             const app = container.get(TestBackendApplication);
             const shutdownPromise = app.invokeGracefulShutdown();

package/src/node/backend-application.ts

@@ -161,7 +161,7 @@ export class BackendApplicationCliContribution implements CliContribution {
         conf.option(APP_PROJECT_PATH, { description: 'Sets the application project directory', deprecated: true });
         conf.option('dnsDefaultResultOrder', {
             type: 'string',
-            description: 'Configure Node\'s DNS resolver default behavior, see https://nodejs.org/docs/latest-v22.x/api/dns.html#dnssetdefaultresultorderorder',
+            description: 'Configure Node\'s DNS resolver default behavior, see https://nodejs.org/docs/latest-v24.x/api/dns.html#dnssetdefaultresultorderorder',
             choices: ['ipv4first', 'verbatim', 'nodeDefault'],
             default: DEFAULT_DNS_DEFAULT_RESULT_ORDER
         });
@@ -226,7 +226,7 @@ export class BackendApplication {
 
         // Handles `Ctrl+C` and `kill pid`. Delegates to gracefulShutdown so that
         // root-scoped singletons get their @preDestroy hooks invoked before exit.
-        const onSignal = () => { this.gracefulShutdown().catch(err => console.error(err)); };
+        const onSignal = () => { this.gracefulShutdown().catch(err => this.logger.error(err)); };
         process.on('SIGINT', onSignal);
         process.on('SIGTERM', onSignal);
     }
@@ -407,7 +407,7 @@ export class BackendApplication {
             ]);
         } catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            console.warn(`Backend contributions cleanup failed: ${message}`);
+            this.logger.warn(`Backend contributions cleanup failed: ${message}`);
         }
 
         try {
@@ -417,7 +417,7 @@ export class BackendApplication {
             ]);
         } catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            console.warn(`Backend root container cleanup failed: ${message}`);
+            this.logger.warn(`Backend root container cleanup failed: ${message}`);
         }
 
         process.exit(1);
@@ -428,7 +428,7 @@ export class BackendApplication {
             return;
         }
         this.stoppedContributions = true;
-        console.info('>>> Stopping backend contributions...');
+        this.logger.info('>>> Stopping backend contributions...');
         // The `async` wrapper converts a synchronous throw inside a non-async
         // contribution's `onStop` into a rejected promise so the per-contribution
         // try/catch can handle it; otherwise `Promise.all` would abort.
@@ -441,7 +441,7 @@ export class BackendApplication {
                 }
             }
         }));
-        console.info('<<< All backend contributions have been stopped.');
+        this.logger.info('<<< All backend contributions have been stopped.');
     }
 
     protected onStop(): void {

package/src/node/console-logger-server.ts

@@ -14,6 +14,9 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+// This is the console logger itself, so it cannot log through an ILogger.
+/* eslint-disable @theia/named-logger-check */
+
 import { inject, injectable, postConstruct } from 'inversify';
 import { LoggerWatcher } from '../common/logger-watcher';
 import { LogLevelCliContribution } from './logger-cli-contribution';

package/src/node/env-variables/env-variables-server.ts

@@ -16,7 +16,7 @@
 
 import { join } from 'path';
 import { homedir } from 'os';
-import { injectable } from 'inversify';
+import { injectable, inject, named } from 'inversify';
 import * as drivelist from 'drivelist';
 import { pathExists, mkdir } from 'fs-extra';
 import { EnvVariable, EnvVariablesServer } from '../../common/env-variables';
@@ -24,6 +24,7 @@ import { isWindows } from '../../common/os';
 import { FileUri } from '../../common/file-uri';
 import { BackendApplicationPath } from '../backend-application';
 import { BackendApplicationConfigProvider } from '../backend-application-config-provider';
+import { ILogger } from '../../common/logger';
 
 @injectable()
 export class EnvVariablesServerImpl implements EnvVariablesServer {
@@ -33,9 +34,12 @@ export class EnvVariablesServerImpl implements EnvVariablesServer {
     protected readonly configDirUri: Promise<string>;
     protected readonly pathExistenceCache: { [key: string]: boolean } = {};
 
+    @inject(ILogger) @named('core:EnvVariablesServerImpl')
+    protected readonly logger: ILogger;
+
     constructor() {
         this.configDirUri = this.createConfigDirUri();
-        this.configDirUri.then(configDirUri => console.log(`Configuration directory URI: '${configDirUri}'`));
+        this.configDirUri.then(configDirUri => this.logger.info(`Configuration directory URI: '${configDirUri}'`));
         const prEnv = process.env;
         Object.keys(prEnv).forEach((key: string) => {
             let keyName = key;

package/src/node/hosting/browser-connection-token.spec.ts

@@ -109,19 +109,24 @@ describe('BrowserConnectionTokenBackendContribution', () => {
         interface MockResponse {
             cookieCalls: CookieCall[];
             nextCalled: boolean;
+            requestHeaders: Record<string, string | undefined>;
         }
 
-        function callMiddleware(cookieValue?: string): MockResponse {
+        function callMiddleware(cookieValue?: string, conditionalHeaders = false): MockResponse {
             const contribution = createContribution();
-            const result: MockResponse = { cookieCalls: [], nextCalled: false };
-
             const req = {
                 headers: {} as Record<string, string | undefined>,
                 socket: { remoteAddress: '127.0.0.1' }
             };
+            const result: MockResponse = { cookieCalls: [], nextCalled: false, requestHeaders: req.headers };
+
             if (cookieValue !== undefined) {
                 req.headers.cookie = `${BROWSER_TOKEN_COOKIE_NAME}=${cookieValue}`;
             }
+            if (conditionalHeaders) {
+                req.headers['if-none-match'] = 'W/"etag"';
+                req.headers['if-modified-since'] = 'Thu, 01 Jan 2026 00:00:00 GMT';
+            }
 
             const res = {
                 cookie: (name: string, value: string, options: Record<string, unknown>) => {
@@ -164,6 +169,28 @@ describe('BrowserConnectionTokenBackendContribution', () => {
             expect(result.cookieCalls).to.have.length(1);
             expect(result.cookieCalls[0].value).to.equal(token.value);
         });
+
+        it('should drop conditional request headers when re-issuing the cookie (stale token)', () => {
+            const result = callMiddleware('stale-token-from-old-server', true);
+            expect(result.nextCalled).to.be.true;
+            expect(result.cookieCalls).to.have.length(1);
+            expect(result.requestHeaders['if-none-match']).to.be.undefined;
+            expect(result.requestHeaders['if-modified-since']).to.be.undefined;
+        });
+
+        it('should drop conditional request headers when issuing the cookie (no cookie)', () => {
+            const result = callMiddleware(undefined, true);
+            expect(result.cookieCalls).to.have.length(1);
+            expect(result.requestHeaders['if-none-match']).to.be.undefined;
+            expect(result.requestHeaders['if-modified-since']).to.be.undefined;
+        });
+
+        it('should keep conditional request headers when the cookie is valid', () => {
+            const result = callMiddleware(token.value, true);
+            expect(result.cookieCalls).to.have.length(0);
+            expect(result.requestHeaders['if-none-match']).to.equal('W/"etag"');
+            expect(result.requestHeaders['if-modified-since']).to.equal('Thu, 01 Jan 2026 00:00:00 GMT');
+        });
     });
 
     describe('validateRequest (HTTP token enforcement)', () => {

package/src/node/hosting/browser-connection-token.ts

@@ -18,12 +18,13 @@ import * as cookie from 'cookie';
 import * as crypto from 'crypto';
 import * as http from 'http';
 import express = require('express');
-import { inject, injectable } from 'inversify';
+import { inject, injectable, named } from 'inversify';
 import { environment } from '../../common/index';
 import { MaybePromise } from '../../common';
 import { BackendApplicationContribution, EarlyExpressMiddleware } from '../backend-application';
 import { WsRequestValidatorContribution } from '../ws-request-validators';
 import { generateUuid } from '../../common/uuid';
+import { ILogger } from '../../common/logger';
 
 export const BrowserConnectionToken = Symbol('BrowserConnectionToken');
 
@@ -79,6 +80,9 @@ export class BrowserConnectionTokenBackendContribution implements BackendApplica
     @inject(EarlyExpressMiddleware)
     protected readonly earlyMiddleware: EarlyExpressMiddleware;
 
+    @inject(ILogger) @named('core:BrowserConnectionTokenBackendContribution')
+    protected readonly logger: ILogger;
+
     /**
      * Register the cookie middleware during `initialize()` via `EarlyExpressMiddleware`
      * so it runs before `express.static()` (which is registered later during `configure()`).
@@ -138,6 +142,13 @@ export class BrowserConnectionTokenBackendContribution implements BackendApplica
                 sameSite: 'strict',
                 path: '/'
             });
+            // The static handlers would answer a revalidation of an unchanged page with a 304,
+            // and reverse proxies commonly drop Set-Cookie from 304 replies or answer the
+            // revalidation from their own cache. The browser would then keep the stale token
+            // and every WebSocket handshake would be rejected, with no way to recover short of
+            // a cache-bypassing hard reload. Force a full 200 so the cookie reaches the browser.
+            delete req.headers['if-none-match'];
+            delete req.headers['if-modified-since'];
         }
         next();
     }
@@ -156,7 +167,7 @@ export class BrowserConnectionTokenBackendContribution implements BackendApplica
             const expected = Buffer.from(this.browserConnectionToken.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/key-store-server.ts

@@ -21,12 +21,15 @@
 // code copied and modified from https://github.com/microsoft/vscode/blob/1.55.2/src/vs/platform/native/electron-main/nativeHostMainService.ts#L679-L771
 
 import { KeyStoreService } from '../common/key-store';
-import { injectable } from 'inversify';
-import { isWindows } from '../common';
+import { injectable, inject, named } from 'inversify';
+import { isWindows, ILogger } from '../common';
 
 @injectable()
 export class KeyStoreServiceImpl implements KeyStoreService {
 
+    @inject(ILogger) @named('core:KeyStoreServiceImpl')
+    protected readonly logger: ILogger;
+
     private static readonly MAX_PASSWORD_LENGTH = 2500;
     private static readonly PASSWORD_CHUNK_SIZE = KeyStoreServiceImpl.MAX_PASSWORD_LENGTH - 100;
 
@@ -108,7 +111,7 @@ export class KeyStoreServiceImpl implements KeyStoreService {
             await this.keytarImplementation.findCredentials('test-keytar-loads');
         } catch (err) {
             this.keytarImplementation = new InMemoryCredentialsProvider();
-            console.warn('OS level credential store could not be accessed. Using in-memory credentials provider', err);
+            this.logger.warn('OS level credential store could not be accessed. Using in-memory credentials provider', err);
         }
         return this.keytarImplementation;
     }

package/src/node/logger-cli-contribution.ts

@@ -14,6 +14,9 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+// Parses the log config the loggers are built from, so no ILogger exists yet.
+/* eslint-disable @theia/named-logger-check */
+
 import * as yargs from 'yargs';
 import { injectable } from 'inversify';
 import { LogLevel } from '../common/logger';

package/src/node/messaging/default-messaging-service.ts

@@ -75,7 +75,7 @@ export class DefaultMessagingService implements MessagingService, BackendApplica
     protected createMainChannelContainer(socket: Channel): Container {
         const connectionContainer: Container = this.container.createChild() as Container;
         connectionContainer.bind(MainChannel).toConstantValue(socket);
-        socket.onClose(() => connectionContainer.unbindAllAsync().catch(e => console.error(e)));
+        socket.onClose(() => connectionContainer.unbindAllAsync().catch(e => this.logger.error(e)));
         return connectionContainer;
     }
 

package/src/node/messaging/ipc-connection-provider.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import * as cp from 'child_process';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, named } from 'inversify';
 import * as path from 'path';
 import { createInterface } from 'readline';
 import { Channel, ConnectionErrorHandler, Disposable, DisposableCollection, ILogger } from '../../common';
@@ -38,7 +38,7 @@ export type IPCConnectionOptions = Partial<ResolvedIPCConnectionOptions> & {
 @injectable()
 export class IPCConnectionProvider {
 
-    @inject(ILogger)
+    @inject(ILogger) @named('core:IPCConnectionProvider')
     protected readonly logger: ILogger;
 
     listen(options: IPCConnectionOptions, acceptor: (connection: Channel) => void): Disposable {

package/src/node/messaging/websocket-endpoint.ts

@@ -55,7 +55,7 @@ export class WebsocketEndpoint implements BackendApplicationContribution {
                 this.wsRequestValidator.allowWsUpgrade(req).then(
                     allowed => callback(noError, allowed),
                     error => {
-                        console.error('Error during WebSocket allowRequest validation:', error);
+                        this.logger.error('Error during WebSocket allowRequest validation:', error);
                         callback(error?.message ?? 'Validation error', false);
                     }
                 );

package/src/node/messaging/websocket-frontend-connection-service.ts

@@ -15,7 +15,7 @@
 
 import { Channel, WriteBuffer } from '../../common/message-rpc';
 import { MessagingService } from './messaging-service';
-import { inject, injectable, interfaces } from 'inversify';
+import { inject, injectable, interfaces, named } from 'inversify';
 import { Socket } from 'socket.io';
 import { ConnectionHandlers, MessagingContainer } from './default-messaging-service';
 import { SocketWriteBuffer } from '../../common/messaging/socket-write-buffer';
@@ -25,7 +25,7 @@ import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/messag
 import { BackendApplicationConfigProvider } from '../backend-application-config-provider';
 import { WebsocketEndpoint } from './websocket-endpoint';
 import { ConnectionManagementMessages } from '../../common/messaging/connection-management';
-import { Disposable, DisposableCollection } from '../../common';
+import { Disposable, DisposableCollection, ILogger } from '../../common';
 
 @injectable()
 export class WebsocketFrontendConnectionService implements FrontendConnectionService {
@@ -36,6 +36,9 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     @inject(MessagingContainer)
     protected readonly container: interfaces.Container;
 
+    @inject(ILogger) @named('core:WebsocketFrontendConnectionService')
+    protected readonly logger: ILogger;
+
     protected readonly wsHandlers = new ConnectionHandlers();
     protected readonly connectionsByFrontend = new Map<string, ReconnectableSocketChannel>();
     protected readonly closeTimeouts = new Map<string, NodeJS.Timeout>();
@@ -65,7 +68,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
             socket.off(ConnectionManagementMessages.RECONNECT, reconnectListener);
             const channel = this.connectionsByFrontend.get(frontEndId);
             if (channel) {
-                console.info(`Reconnecting to front end ${frontEndId}`);
+                this.logger.info(`Reconnecting to front end ${frontEndId}`);
                 socket.emit(ConnectionManagementMessages.RECONNECT, true);
                 channel.connect(socket);
                 this.handleSocketDisconnect(socket, channel, frontEndId);
@@ -73,7 +76,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
                 clearTimeout(pendingTimeout);
                 this.closeTimeouts.delete(frontEndId);
             } else {
-                console.info(`Reconnecting failed for ${frontEndId}`);
+                this.logger.info(`Reconnecting failed for ${frontEndId}`);
                 socket.emit(ConnectionManagementMessages.RECONNECT, false);
             }
         };
@@ -82,7 +85,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     }
 
     protected closeConnection(frontEndId: string, reason: string): void {
-        console.info(`closing connection for ${frontEndId}`);
+        this.logger.info(`closing connection for ${frontEndId}`);
         const connection = this.connectionsByFrontend.get(frontEndId)!; // not called when no connection is present
 
         this.connectionsByFrontend.delete(frontEndId);
@@ -97,7 +100,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     }
 
     protected createConnection(socket: Socket, frontEndId: string): ReconnectableSocketChannel {
-        console.info(`creating connection for ${frontEndId}`);
+        this.logger.info(`creating connection for ${frontEndId}`);
         const channel = this.container.get(ReconnectableSocketChannel);
         channel.connect(socket);
 
@@ -107,7 +110,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
 
     handleSocketDisconnect(socket: Socket, channel: ReconnectableSocketChannel, frontEndId: string): void {
         socket.on('disconnect', evt => {
-            console.info('socket closed');
+            this.logger.info('socket closed');
             channel.disconnect();
 
             const timeout = this.frontendConnectionTimeout();
@@ -115,7 +118,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
             if (timeout === 0 || isMarkedForClose) {
                 this.closeConnection(frontEndId, evt);
             } else if (timeout > 0) {
-                console.info(`setting close timeout for id ${frontEndId} to ${timeout}`);
+                this.logger.info(`setting close timeout for id ${frontEndId} to ${timeout}`);
                 const handle = setTimeout(() => {
                     this.closeConnection(frontEndId, evt);
                 }, timeout);

package/src/node/setting-service.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { promises as fs } from 'fs';
-import { inject, injectable, postConstruct } from 'inversify';
+import { inject, injectable, postConstruct, named } from 'inversify';
 import { ILogger, URI } from '../common';
 import { EnvVariablesServer } from '../common/env-variables';
 import { Deferred } from '../common/promise-util';
@@ -32,7 +32,7 @@ export interface SettingService {
 
 @injectable()
 export class SettingServiceImpl implements SettingService {
-    @inject(ILogger)
+    @inject(ILogger) @named('core:SettingServiceImpl')
     protected readonly logger: ILogger;
 
     @inject(EnvVariablesServer)