@theia/core 1.73.0-next.3 → 1.73.0-next.39

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/logger-cli-contribution.spec.ts

@@ -257,4 +257,69 @@ describe('log-level-cli-contribution', () => {
             world: LogLevel.FATAL,
         });
     });
+
+    describe('Wildcard Matching', () => {
+
+        async function setupLogLevels(levels: { [key: string]: string }): Promise<void> {
+            const file = track.openSync();
+            fs.writeFileSync(file.fd, JSON.stringify({
+                defaultLevel: 'info',
+                levels
+            }));
+            fs.fsyncSync(file.fd);
+            fs.closeSync(file.fd);
+
+            const args: yargs.Arguments = await yargs.parse(['--log-config', file.path]);
+            await cli.setArguments(args);
+        }
+
+        it('should respect exact matches without wildcards', async () => {
+            await setupLogLevels({
+                'unrelated:Service': 'debug'
+            });
+            expect(cli.logLevelFor('unrelated:Service')).to.equal(LogLevel.DEBUG);
+            expect(cli.logLevelFor('something-else')).to.equal(LogLevel.INFO);
+        });
+
+        it('should match prefix wildcards', async () => {
+            await setupLogLevels({
+                'ai-core*': 'error'
+            });
+            expect(cli.logLevelFor('ai-core:SomeOtherService')).to.equal(LogLevel.ERROR);
+        });
+
+        it('should match suffix wildcards', async () => {
+            await setupLogLevels({
+                '*TokenUsageFrontendServiceImpl': 'warn'
+            });
+            expect(cli.logLevelFor('my-package:MyTokenUsageFrontendServiceImpl')).to.equal(LogLevel.WARN);
+        });
+
+        it('should match middle wildcards', async () => {
+            await setupLogLevels({
+                '*ai*:*': 'warn'
+            });
+            expect(cli.logLevelFor('foo-ai-bar:SomeService')).to.equal(LogLevel.WARN);
+        });
+
+        it('should enforce perfect match first, then last wildcard wins', async () => {
+            await setupLogLevels({
+                'ai-core*': 'error',
+                '*ai*:*': 'warn',
+                'ai-core:SpecificService': 'debug'
+            });
+
+            expect(cli.logLevelFor('ai-core:SpecificService')).to.equal(LogLevel.DEBUG);
+
+            expect(cli.logLevelFor('ai-core:OtherService')).to.equal(LogLevel.WARN);
+        });
+
+        it('should properly escape regex specifics like periods', async () => {
+            await setupLogLevels({
+                '.*': 'error'
+            });
+            expect(cli.logLevelFor('anything-else')).to.equal(LogLevel.INFO);
+            expect(cli.logLevelFor('.*')).to.equal(LogLevel.ERROR);
+        });
+    });
 });

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

@@ -23,6 +23,7 @@ import { AsyncSubscription, subscribe } from '@parcel/watcher';
 import { Event, Emitter } from '../common/event';
 import * as path from 'path';
 import { Disposable, DisposableCollection } from '../common';
+import { escapeRegExpCharacters } from '../common/strings';
 
 /** Maps logger names to log levels.  */
 export interface LogLevels {
@@ -38,6 +39,7 @@ export interface LogLevels {
 export class LogLevelCliContribution implements CliContribution, Disposable {
 
     protected _logLevels: LogLevels = {};
+    protected wildcardRegexCache = new Map<string, RegExp>();
     protected asyncSubscriptions: AsyncSubscription[] = [];
     protected toDispose = new DisposableCollection();
 
@@ -190,6 +192,7 @@ export class LogLevelCliContribution implements CliContribution, Disposable {
 
             this._defaultLogLevel = newDefaultLogLevel;
             this._logLevels = newLogLevels;
+            this.wildcardRegexCache.clear();
 
             console.log(`Successfully read new log config from ${filename}.`);
         } catch (e) {
@@ -202,13 +205,23 @@ export class LogLevelCliContribution implements CliContribution, Disposable {
     }
 
     logLevelFor(loggerName: string): LogLevel {
-        const level = this._logLevels[loggerName];
+        if (loggerName in this._logLevels) {
+            return this._logLevels[loggerName];
+        }
+
+        const keys = Object.keys(this._logLevels);
+        for (let i = keys.length - 1; i >= 0; i--) {
+            const pattern = keys[i];
 
-        if (level !== undefined) {
-            return level;
-        } else {
-            return this.defaultLogLevel;
+            if (pattern.includes('*')) {
+                const regex = this.getWildcardRegex(pattern);
+                if (regex.test(loggerName)) {
+                    return this._logLevels[pattern];
+                }
+            }
         }
+
+        return this.defaultLogLevel;
     }
 
     /**
@@ -223,4 +236,18 @@ export class LogLevelCliContribution implements CliContribution, Disposable {
 
         return level;
     }
+
+    /**
+     * Converts a wildcard string into a strict regular expression and caches it.
+     * Example: "ai-core*" -> /^ai-core.*$/
+     */
+    protected getWildcardRegex(pattern: string): RegExp {
+        let regex = this.wildcardRegexCache.get(pattern);
+        if (!regex) {
+            const escapedPattern = pattern.split('*').map(escapeRegExpCharacters).join('.*');
+            regex = new RegExp(`^${escapedPattern}$`);
+            this.wildcardRegexCache.set(pattern, regex);
+        }
+        return regex;
+    }
 }

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