@theia/core 1.73.0-next.20 → 1.73.0-next.26

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

@@ -394,6 +394,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 +406,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;
     }
 

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);
             }
         }
     }

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

@@ -22,6 +22,7 @@ import Route = require('route-parser');
 import { Channel, ChannelMultiplexer } from '../../common/message-rpc/channel';
 import { FrontendConnectionService } from './frontend-connection-service';
 import { BackendApplicationContribution } from '../backend-application';
+import { ILogger } from '../../common/logger';
 
 export const MessagingContainer = Symbol('MessagingContainer');
 export const MainChannel = Symbol('MainChannel');
@@ -37,6 +38,9 @@ export class DefaultMessagingService implements MessagingService, BackendApplica
     @inject(ContributionProvider) @named(ConnectionContainerModule)
     protected readonly connectionModules: ContributionProvider<interfaces.ContainerModule>;
 
+    @inject(ILogger) @named('core:DefaultMessagingService')
+    protected readonly logger: ILogger;
+
     @inject(ContributionProvider) @named(MessagingService.Contribution)
     protected readonly contributions: ContributionProvider<MessagingService.Contribution>;
 
@@ -62,8 +66,8 @@ export class DefaultMessagingService implements MessagingService, BackendApplica
         const channelHandlers = this.getConnectionChannelHandlers(channel);
         multiplexer.onDidOpenChannel(event => {
             if (channelHandlers.route(event.id, event.channel)) {
-                console.debug(`Opening channel for service path '${event.id}'.`);
-                event.channel.onClose(() => console.info(`Closing channel on service path '${event.id}'.`));
+                this.logger.debug(`Opening channel for service path '${event.id}'.`);
+                event.channel.onClose(() => this.logger.info(`Closing channel on service path '${event.id}'.`));
             }
         });
     }

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

@@ -16,13 +16,14 @@
 
 import { expect } from 'chai';
 import { Container, injectable, preDestroy } from 'inversify';
-import { ConnectionHandler, bindContributionProvider, servicesPath } from '../../../common';
+import { ConnectionHandler, bindContributionProvider, servicesPath, ILogger } from '../../../common';
 import { BasicChannel, Channel } from '../../../common/message-rpc/channel';
 import { Uint8ArrayWriteBuffer } from '../../../common/message-rpc/uint8-array-message-buffer';
 import { ConnectionContainerModule } from '../connection-container-module';
 import { DefaultMessagingService, MessagingContainer } from '../default-messaging-service';
 import { FrontendConnectionService } from '../frontend-connection-service';
 import { MessagingService } from '../messaging-service';
+import { MockLogger } from '../../../common/test/mock-logger';
 
 describe('DefaultMessagingService', () => {
 
@@ -63,6 +64,7 @@ describe('DefaultMessagingService', () => {
                 }
             };
             container.bind(FrontendConnectionService).toConstantValue(frontendConnectionService);
+            container.bind(ILogger).to(MockLogger).inSingletonScope();
 
             const messagingService = container.get(DefaultMessagingService);
             messagingService.initialize();

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

@@ -16,12 +16,13 @@
 import { MessagingService } from './messaging-service';
 import * as http from 'http';
 import * as https from 'https';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, named } from 'inversify';
 import { Server, Socket } from 'socket.io';
 import { WsRequestValidator } from '../ws-request-validators';
 import { MessagingListener } from './messaging-listeners';
 import { ConnectionHandlers } from './default-messaging-service';
 import { BackendApplicationContribution } from '../backend-application';
+import { ILogger } from '../../common/logger';
 
 @injectable()
 export class WebsocketEndpoint implements BackendApplicationContribution {
@@ -31,6 +32,9 @@ export class WebsocketEndpoint implements BackendApplicationContribution {
     @inject(MessagingListener)
     protected readonly messagingListener: MessagingListener;
 
+    @inject(ILogger) @named('core:WebsocketEndpoint')
+    protected readonly logger: ILogger;
+
     protected checkAliveTimeout = 30000; // 30 seconds
     protected maxHttpBufferSize = 1e8; // 100 MB
 
@@ -72,7 +76,7 @@ export class WebsocketEndpoint implements BackendApplicationContribution {
     protected async handleConnection(socket: Socket): Promise<void> {
         const pathname = socket.nsp.name;
         if (pathname && !this.wsHandlers.route(pathname, socket)) {
-            console.error('Cannot find a ws handler for the path: ' + pathname);
+            this.logger.error('Cannot find a ws handler for the path: ' + pathname);
         }
     }
 }

package/src/node/process-utils.spec.ts

@@ -15,8 +15,11 @@
 // *****************************************************************************
 
 import { expect } from 'chai';
+import * as sinon from 'sinon';
 import { Container } from 'inversify';
 import { ProcessUtils } from './process-utils';
+import { ILogger } from '../common';
+import { MockLogger } from '../common/test/mock-logger';
 
 /** PPID, PID */
 const mockPsOutput = `\
@@ -36,6 +39,8 @@ describe('ProcessUtils', () => {
     beforeEach(() => {
         const container = new Container();
         container.bind(ProcessUtils).toSelf().inSingletonScope();
+        container.bind(ILogger).to(MockLogger).inSingletonScope();
+
         coreProcessManager = container.get(ProcessUtils);
     });
 
@@ -48,8 +53,7 @@ describe('ProcessUtils', () => {
 
     describe('#unixTerminateProcessTree', () => {
         let originalKill: typeof process.kill;
-        let originalConsoleError: typeof console.error;
-        let loggedErrors: unknown[];
+        let errorStub: sinon.SinonStub;
 
         function throwingKill(code: string): typeof process.kill {
             return (() => {
@@ -61,9 +65,8 @@ describe('ProcessUtils', () => {
 
         beforeEach(() => {
             originalKill = process.kill;
-            originalConsoleError = console.error;
-            loggedErrors = [];
-            console.error = (...args: unknown[]) => { loggedErrors.push(args); };
+            const mockLogger = (coreProcessManager as unknown as { logger: ILogger }).logger;
+            errorStub = sinon.stub(mockLogger, 'error');
             // One child plus the parent; report the parent as its own group leader so the `kill(-ppid)` branch runs too.
             coreProcessManager['unixGetChildrenRecursive'] = () => new Set([424242]);
             coreProcessManager['unixGetPGID'] = (pid: number) => pid;
@@ -71,26 +74,26 @@ describe('ProcessUtils', () => {
 
         afterEach(() => {
             process.kill = originalKill;
-            console.error = originalConsoleError;
+            sinon.restore();
         });
 
         it('does not throw or log when processes in the tree are already gone (ESRCH)', () => {
             process.kill = throwingKill('ESRCH');
             expect(() => coreProcessManager['unixTerminateProcessTree'](424243)).to.not.throw();
-            expect(loggedErrors).to.be.empty;
+            expect(errorStub.called).to.be.false;
         });
 
         it('logs unexpected kill errors (e.g. EPERM) without throwing', () => {
             process.kill = throwingKill('EPERM');
             expect(() => coreProcessManager['unixTerminateProcessTree'](424243)).to.not.throw();
-            expect(loggedErrors).to.not.be.empty;
+            expect(errorStub.called).to.be.true;
         });
 
         it('does not throw when a kill rejects with a value that has no code (e.g. undefined)', () => {
             const thrown: unknown = undefined;
             process.kill = (() => { throw thrown; }) as typeof process.kill;
             expect(() => coreProcessManager['unixTerminateProcessTree'](424243)).to.not.throw();
-            expect(loggedErrors).to.not.be.empty;
+            expect(errorStub.called).to.be.true;
         });
     });
 });

package/src/node/process-utils.ts

@@ -15,7 +15,8 @@
 // *****************************************************************************
 
 import * as cp from 'child_process';
-import { injectable } from 'inversify';
+import { injectable, inject, named } from 'inversify';
+import { ILogger } from '../common/logger';
 
 /**
  * `@theia/core` service with some process-related utilities.
@@ -23,6 +24,9 @@ import { injectable } from 'inversify';
 @injectable()
 export class ProcessUtils {
 
+    @inject(ILogger) @named('core:ProcessUtils')
+    protected readonly logger: ILogger;
+
     terminateProcessTree(ppid: number): void {
         if (process.platform === 'win32') {
             this.winTerminateProcessTree(ppid);
@@ -39,7 +43,7 @@ export class ProcessUtils {
         // taskkill may exit with a non-zero code when some child processes have already exited.
         // This is expected during shutdown — log but don't throw.
         if (result.status !== 0) {
-            console.warn(`taskkill.exe exited with ${result.status} for PID ${ppid}. Output:\n${JSON.stringify(result.output)}`);
+            this.logger.warn(`taskkill.exe exited with ${result.status} for PID ${ppid}. Output:\n${JSON.stringify(result.output)}`);
         }
     }
 
@@ -66,7 +70,7 @@ export class ProcessUtils {
             // ESRCH means the process is already gone, which is the goal here. Log
             // anything else but keep going so the rest of the tree is still killed.
             if ((error as NodeJS.ErrnoException | undefined)?.code !== 'ESRCH') {
-                console.error(`[${pid}] failed to kill`, error);
+                this.logger.error(`[${pid}] failed to kill`, error);
             }
         }
     }