@theia/core 1.73.0-next.31 → 1.73.0-next.40

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

@@ -239,7 +239,7 @@ export function createPreferenceProxy<T>(preferences: PreferenceService, promise
         return properties;
     };
 
-    const set: (target: any, prop: string, value: any, receiver: any) => boolean = (_, property: string | symbol | number, value: any) => {
+    const set: (target: any, prop: string | symbol, value: any, receiver: any) => boolean = (_, property: string | symbol | number, value: any) => {
         if (typeof property !== 'string') {
             throw new Error(`unexpected property: ${String(property)}`);
         }
@@ -270,7 +270,13 @@ export function createPreferenceProxy<T>(preferences: PreferenceService, promise
         return false;
     };
 
-    const get: (target: any, prop: string) => any = (_, property: string | symbol | number) => {
+    const get: (target: any, prop: string | symbol) => any = (_, property: string | symbol | number) => {
+        // React 19 dev mode calls Object.prototype.toString when handling prop diffs, which
+        // probes Symbol.toStringTag. Throwing should be avoided in this case, it crashes the React DOM.
+        if (property === Symbol.toStringTag) {
+            return undefined;
+        }
+
         if (typeof property !== 'string') {
             throw new Error(`unexpected property: ${String(property)}`);
         }
@@ -347,8 +353,8 @@ export function createPreferenceProxy<T>(preferences: PreferenceService, promise
     return new Proxy({}, {
         get,
         ownKeys,
-        getOwnPropertyDescriptor: (_, property: string) => {
-            if (ownKeys().indexOf(property) !== -1) {
+        getOwnPropertyDescriptor: (_, property: string | symbol) => {
+            if (typeof property === 'string' && ownKeys().indexOf(property) !== -1) {
                 return {
                     enumerable: true,
                     configurable: true

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