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

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