@theia/core 1.71.0-next.64 → 1.71.0-next.72

package/src/common/performance/stopwatch.spec.ts

@@ -0,0 +1,321 @@
+// *****************************************************************************
+// Copyright (C) 2026 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Deferred } from '../promise-util';
+import { Measurement, MeasurementOptions } from './measurement';
+import { MeasurementContext } from './stopwatch';
+import { SimpleStopwatch } from './simple-stopwatch';
+
+/**
+ * A fake {@link Measurement} whose log methods are sinon spies, with a
+ * configurable duration returned by {@link stop}.
+ */
+class FakeMeasurement implements Measurement {
+    name: string;
+    elapsed?: number;
+    duration: number;
+
+    readonly log = sinon.spy();
+    readonly info = sinon.spy();
+    readonly debug = sinon.spy();
+    readonly warn = sinon.spy();
+    readonly error = sinon.spy();
+
+    readonly stop = sinon.spy((): number => {
+        if (this.elapsed === undefined) {
+            this.elapsed = this.duration;
+        }
+        return this.elapsed;
+    });
+
+    constructor(name: string, duration: number = 0) {
+        this.name = name;
+        this.duration = duration;
+    }
+}
+
+/**
+ * A fake {@link Stopwatch} that creates {@link FakeMeasurement}s with
+ * configurable durations and records all invocations of {@link start}.
+ */
+class FakeStopwatch extends SimpleStopwatch {
+    defaultDuration = 0;
+    readonly durationByName = new Map<string, number>();
+    readonly created: FakeMeasurement[] = [];
+
+    override readonly start = sinon.spy((name: string, _options?: MeasurementOptions): Measurement => {
+        const duration = this.durationByName.get(name) ?? this.defaultDuration;
+        const measurement = new FakeMeasurement(name, duration);
+        this.created.push(measurement);
+        return measurement;
+    });
+
+    constructor() {
+        super('test', () => 0);
+    }
+
+    /** Return the first measurement created with the given name, or `undefined`. */
+    measurementFor(name: string): FakeMeasurement | undefined {
+        return this.created.find(m => m.name === name);
+    }
+}
+
+class TestContribution { }
+class OtherTestContribution { }
+
+/**
+ * Allow any already-queued microtasks (such as `.then` callbacks attached to
+ * already-settled promises) to run before assertions.
+ */
+async function flushPromises(): Promise<void> {
+    for (let i = 0; i < 5; i++) {
+        await Promise.resolve();
+    }
+}
+
+describe('MeasurementContext', () => {
+
+    let stopwatch: FakeStopwatch;
+
+    beforeEach(() => {
+        stopwatch = new FakeStopwatch();
+    });
+
+    describe('ensureEntry', () => {
+
+        it('starts a per-contribution measurement', () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 250);
+
+            context.ensureEntry(new TestContribution());
+
+            sinon.assert.calledWith(stopwatch.start, 'TestContribution.settled', sinon.match({ thresholdMillis: 250 }));
+        });
+
+        it('starts a per-contribution measurement only once per item', () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+
+            context.ensureEntry(item);
+            context.ensureEntry(item);
+            context.ensureEntry(item);
+
+            const started = stopwatch.start.getCalls().filter(c => c.args[0] === 'TestContribution.settled');
+            expect(started).to.have.length(1);
+        });
+
+        it('starts independent measurements for distinct items', () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+
+            context.ensureEntry(new TestContribution());
+            context.ensureEntry(new TestContribution());
+
+            const started = stopwatch.start.getCalls().filter(c => c.args[0] === 'TestContribution.settled');
+            expect(started).to.have.length(2);
+        });
+    });
+
+    describe('trackSettlement', () => {
+
+        it('is a no-op for a synchronous result', async () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            context.trackSettlement(item, undefined);
+            context.armAllSettled();
+            await flushPromises();
+
+            const perContribution = stopwatch.measurementFor('TestContribution.settled')!;
+            sinon.assert.notCalled(perContribution.debug);
+            sinon.assert.notCalled(perContribution.warn);
+            sinon.assert.notCalled(perContribution.info);
+
+            // Synchronous results do not increment allSettledPending, so arming fires the
+            // aggregate message immediately.
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.calledOnce(allSettled.info);
+        });
+
+        it('does not log a per-contribution settlement when only one promise was tracked', async () => {
+            // The single lifecycle measurement already describes the duration of a solo tracked
+            // promise, so the per-contribution aggregate must stay silent.
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            context.trackSettlement(item, Promise.resolve());
+            context.armAllSettled();
+            await flushPromises();
+
+            const perContribution = stopwatch.measurementFor('TestContribution.settled')!;
+            sinon.assert.notCalled(perContribution.debug);
+            sinon.assert.notCalled(perContribution.warn);
+            sinon.assert.notCalled(perContribution.info);
+        });
+
+        it('logs a debug settlement message once multiple tracked promises all resolve under the threshold', async () => {
+            stopwatch.durationByName.set('TestContribution.settled', 50);
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            const first = new Deferred<void>();
+            const second = new Deferred<void>();
+            context.trackSettlement(item, first.promise);
+            context.trackSettlement(item, second.promise);
+
+            // Before any promise resolves, nothing has been logged.
+            const perContribution = stopwatch.measurementFor('TestContribution.settled')!;
+            sinon.assert.notCalled(perContribution.debug);
+
+            first.resolve();
+            await flushPromises();
+            sinon.assert.notCalled(perContribution.debug);
+
+            second.resolve();
+            await flushPromises();
+            sinon.assert.calledOnceWithExactly(perContribution.debug, 'Frontend TestContribution settled');
+            sinon.assert.notCalled(perContribution.warn);
+        });
+
+        it('logs a warn settlement message when multiple tracked promises exceed the threshold', async () => {
+            stopwatch.durationByName.set('TestContribution.settled', 500);
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            context.trackSettlement(item, Promise.resolve());
+            context.trackSettlement(item, Promise.resolve());
+            await flushPromises();
+
+            const perContribution = stopwatch.measurementFor('TestContribution.settled')!;
+            sinon.assert.calledOnceWithExactly(perContribution.warn, 'Frontend TestContribution took longer than expected to settle');
+            sinon.assert.notCalled(perContribution.debug);
+        });
+
+        it('treats a rejected promise as settled', async () => {
+            stopwatch.durationByName.set('TestContribution.settled', 10);
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            const rejecting = new Deferred<void>();
+            context.trackSettlement(item, Promise.resolve());
+            context.trackSettlement(item, rejecting.promise);
+            rejecting.reject(new Error('expected failure'));
+            await flushPromises();
+
+            const perContribution = stopwatch.measurementFor('TestContribution.settled')!;
+            sinon.assert.calledOnce(perContribution.debug);
+        });
+
+        it('tracks promises independently for each contribution', async () => {
+            stopwatch.durationByName.set('TestContribution.settled', 50);
+            stopwatch.durationByName.set('OtherTestContribution.settled', 50);
+            const context = new MeasurementContext<object>(stopwatch, 'Frontend', 100);
+
+            const a = new TestContribution();
+            const b = new OtherTestContribution();
+            context.ensureEntry(a);
+            context.ensureEntry(b);
+
+            context.trackSettlement(a, Promise.resolve());
+            context.trackSettlement(a, Promise.resolve());
+            context.trackSettlement(b, Promise.resolve());
+            await flushPromises();
+
+            // a had two tracked promises: logs once.
+            sinon.assert.calledOnce(stopwatch.measurementFor('TestContribution.settled')!.debug);
+            // b had a single tracked promise: logs nothing.
+            sinon.assert.notCalled(stopwatch.measurementFor('OtherTestContribution.settled')!.debug);
+        });
+    });
+
+    describe('armAllSettled', () => {
+
+        it('logs the aggregate message immediately when armed with zero pending promises', () => {
+            const context = new MeasurementContext(stopwatch, 'Frontend', 100);
+
+            context.armAllSettled();
+
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.calledOnceWithExactly(allSettled.info, 'All frontend contributions settled');
+        });
+
+        it('defers the aggregate log until the last tracked promise settles', async () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            const pending = new Deferred<void>();
+            context.trackSettlement(item, pending.promise);
+            context.armAllSettled();
+
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.notCalled(allSettled.info);
+
+            pending.resolve();
+            await flushPromises();
+
+            sinon.assert.calledOnce(allSettled.info);
+        });
+
+        it('does not log the aggregate message when all promises settle before arming', async () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            context.trackSettlement(item, Promise.resolve());
+            await flushPromises();
+
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.notCalled(allSettled.info);
+        });
+
+        it('logs the aggregate message when arming after all tracked promises have already settled', async () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            context.trackSettlement(item, Promise.resolve());
+            await flushPromises();
+
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.notCalled(allSettled.info);
+
+            context.armAllSettled();
+            sinon.assert.calledOnce(allSettled.info);
+        });
+
+        it('logs the aggregate message exactly once when multiple contributions finish', async () => {
+            const context = new MeasurementContext<object>(stopwatch, 'Frontend', 100);
+            const a = new TestContribution();
+            const b = new OtherTestContribution();
+            context.ensureEntry(a);
+            context.ensureEntry(b);
+
+            context.trackSettlement(a, Promise.resolve());
+            context.trackSettlement(b, Promise.resolve());
+            context.armAllSettled();
+            await flushPromises();
+
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.calledOnce(allSettled.info);
+        });
+    });
+});

package/src/common/performance/stopwatch.ts

@@ -170,8 +170,8 @@ export abstract class Stopwatch {
             }
         }
 
-        const start = options.owner ? `${options.owner} start` : 'start';
-        const timeFromStart = `Finished ${(options.now() / 1000).toFixed(3)} s after ${start}`;
+        const origin = options.owner ?? 'application';
+        const timeFromStart = `${(options.now() / 1000).toFixed(3)} s since ${origin} start`;
         const whatWasMeasured = options.context ? `[${options.context}] ${activity}` : activity;
         this.logger.log(level, `${whatWasMeasured}: ${elapsed.toFixed(1)} ms [${timeFromStart}]`, ...(options.arguments ?? []));
     }
@@ -181,3 +181,104 @@ export abstract class Stopwatch {
     }
 
 }
+
+interface SettlementEntry {
+    name: string;
+    measurement: Measurement;
+    pending: number;
+    total: number;
+}
+
+/**
+ * Tracks the settlement of async work initiated by contributions during application startup.
+ *
+ * A contribution "settles" when all promises it returned from lifecycle methods (initialize, configure, onStart, etc.)
+ * have resolved. Individual settlement is only logged when a contribution returned promises from more than one lifecycle
+ * method; otherwise the single lifecycle measurement already describes the work. An aggregate "all settled" message is
+ * logged once all tracked promises across all contributions have resolved.
+ *
+ * Typical usage:
+ * 1. Create the context at the start of the application lifecycle.
+ * 2. Before each lifecycle call, call {@link ensureEntry} to start the per-contribution clock.
+ * 3. After each lifecycle call, call {@link trackSettlement} with the return value.
+ * 4. After the startup sequence completes, call {@link armAllSettled} to enable the aggregate message.
+ */
+export class MeasurementContext<T extends object = object> {
+
+    private readonly entries = new Map<T, SettlementEntry>();
+    private readonly allSettledMeasurement: Measurement;
+    private allSettledPending = 0;
+    private allSettledArmed = false;
+
+    constructor(
+        protected readonly stopwatch: Stopwatch,
+        protected readonly owner: string,
+        protected readonly thresholdMillis: number
+    ) {
+        this.allSettledMeasurement = this.stopwatch.start(`${owner.toLowerCase()}-all-settled`);
+    }
+
+    /**
+     * Ensure that settlement tracking has been started for the given contribution.
+     * Starts the per-contribution measurement clock on the first call for each contribution.
+     */
+    ensureEntry(item: T): void {
+        if (!this.entries.has(item)) {
+            const name = item.constructor.name;
+            this.entries.set(item, {
+                name,
+                measurement: this.stopwatch.start(`${name}.settled`, { thresholdMillis: this.thresholdMillis }),
+                pending: 0,
+                total: 0
+            });
+        }
+    }
+
+    /**
+     * Track a promise returned by a contribution's lifecycle method.
+     * Must be called after the corresponding {@link Stopwatch.startAsync} has completed so that
+     * the settlement log appears after the lifecycle measurement log.
+     */
+    trackSettlement(item: T, result: MaybePromise<unknown>): void {
+        if (result instanceof Promise) {
+            const entry = this.entries.get(item)!;
+            entry.pending++;
+            entry.total++;
+            this.allSettledPending++;
+            const onSettled = (): void => {
+                this.onPromiseSettled(item);
+            };
+            result.then(onSettled, onSettled);
+        }
+    }
+
+    /**
+     * Arm the aggregate "all settled" log message. Call this after the startup sequence has finished
+     * collecting all promises. If all promises have already settled, the message is logged immediately.
+     */
+    armAllSettled(): void {
+        this.allSettledArmed = true;
+        if (this.allSettledPending === 0) {
+            this.allSettledMeasurement.info(`All ${this.owner.toLowerCase()} contributions settled`);
+        }
+    }
+
+    private onPromiseSettled(item: T): void {
+        const entry = this.entries.get(item);
+        if (entry && --entry.pending === 0) {
+            const { name, measurement, total } = entry;
+            this.entries.delete(item);
+            if (total > 1) {
+                if (measurement.stop() > this.thresholdMillis) {
+                    measurement.warn(`${this.owner} ${name} took longer than expected to settle`);
+                } else {
+                    measurement.debug(`${this.owner} ${name} settled`);
+                }
+            }
+        }
+        if (--this.allSettledPending === 0 && this.allSettledArmed) {
+            this.allSettledMeasurement.info(`All ${this.owner.toLowerCase()} contributions settled`);
+        }
+    }
+
+}

package/src/electron-main/electron-main-application-module.ts

@@ -15,8 +15,10 @@
 // *****************************************************************************
 
 import { ContainerModule } from 'inversify';
+import { performance } from 'perf_hooks';
 import { generateUuid } from '../common/uuid';
 import { bindRootContributionProvider } from '../common/contribution-provider';
+import { Stopwatch, SimpleStopwatch } from '../common/performance';
 import { RpcConnectionHandler } from '../common/messaging/proxy-factory';
 import { ElectronSecurityToken } from '../electron-common/electron-token';
 import { ElectronMainWindowService, electronMainWindowServicePath } from '../electron-common/electron-main-window-service';
@@ -34,6 +36,7 @@ const electronSecurityToken: ElectronSecurityToken = { value: generateUuid() };
 (global as any)[ElectronSecurityToken] = electronSecurityToken;
 
 export default new ContainerModule(bind => {
+    bind(Stopwatch).toConstantValue(new SimpleStopwatch('electron main', () => performance.now()));
     bind(ElectronMainApplication).toSelf().inSingletonScope();
     bind(ElectronMessagingContribution).toSelf().inSingletonScope();
     bind(ElectronMainApplicationContribution).toService(ElectronMessagingContribution);

package/src/electron-main/electron-main-application.ts

@@ -30,6 +30,7 @@ import URI from '../common/uri';
 import { FileUri } from '../common/file-uri';
 import { Deferred, timeout } from '../common/promise-util';
 import { MaybePromise } from '../common/types';
+import { Stopwatch } from '../common/performance';
 import { ContributionProvider } from '../common/contribution-provider';
 import { ElectronSecurityTokenService } from './electron-security-token-service';
 import { ElectronSecurityToken } from '../electron-common/electron-token';
@@ -49,6 +50,8 @@ export { ElectronMainApplicationGlobals };
 
 const createYargs: (argv?: string[], cwd?: string) => Argv = require('yargs/yargs');
 
+const ELECTRON_TIMER_WARNING_THRESHOLD = 50;
+
 /**
  * Options passed to the main/default command handler.
  */
@@ -171,6 +174,9 @@ export class ElectronMainApplication {
     @inject(TheiaElectronWindowFactory)
     protected readonly windowFactory: TheiaElectronWindowFactory;
 
+    @inject(Stopwatch)
+    protected readonly stopwatch: Stopwatch;
+
     protected isPortable = this.makePortable();
 
     protected readonly electronStore = new Storage<{
@@ -229,15 +235,19 @@ export class ElectronMainApplication {
                         await fs.mkdir(args.electronUserData, { recursive: true });
                         app.setPath('userData', args.electronUserData);
                     }
+                    const startupMeasurement = this.stopwatch.start('electron-main-startup');
                     this.useNativeWindowFrame = this.getTitleBarStyle(config) === 'native';
                     this._config = config;
                     this.hookApplicationEvents();
                     this.showInitialWindow(argv.includes('--open-url') ? argv[argv.length - 1] : undefined);
-                    const port = await this.startBackend();
+                    const port = await this.stopwatch.startAsync('electron-main-start-backend', 'Starting backend', () => this.startBackend());
                     this._backendPort.resolve(port);
                     await app.whenReady();
-                    await this.attachElectronSecurityToken(port);
-                    await this.startContributions();
+                    await this.stopwatch.startAsync('electron-main-security-token', 'Attaching security token',
+                        () => this.attachElectronSecurityToken(port));
+                    await this.stopwatch.startAsync('electron-main-start-contributions', 'Starting contributions',
+                        () => this.startContributions());
+                    startupMeasurement.info('Startup sequence completed');
 
                     this.handleMainCommand({
                         file: args.file,
@@ -920,8 +930,14 @@ export class ElectronMainApplication {
     protected async startContributions(): Promise<void> {
         const promises = [];
         for (const contribution of this.contributions.getContributions()) {
-            if (contribution.onStart) {
-                promises.push(contribution.onStart(this));
+            const onStart = contribution.onStart;
+            if (onStart) {
+                promises.push(this.stopwatch.startAsync(
+                    `${contribution.constructor.name}.onStart`,
+                    `${contribution.constructor.name}.onStart`,
+                    () => onStart.call(contribution, this),
+                    { thresholdMillis: ELECTRON_TIMER_WARNING_THRESHOLD }
+                ));
             }
         }
         await Promise.all(promises);

package/src/node/backend-application.ts

@@ -22,7 +22,7 @@ import * as express from 'express';
 import * as yargs from 'yargs';
 import * as fs from 'fs-extra';
 import { inject, named, injectable, postConstruct } from 'inversify';
-import { ContributionProvider, MaybePromise, Stopwatch } from '../common';
+import { ContributionProvider, LogLevel, MaybePromise, MeasurementContext, Stopwatch } from '../common';
 import { CliContribution } from './cli';
 import { Deferred } from '../common/promise-util';
 import { environment } from '../common/index';
@@ -164,6 +164,8 @@ export class BackendApplication {
 
     private _configured: Promise<void>;
 
+    private settlementContext?: MeasurementContext<BackendApplicationContribution>;
+
     constructor(
         @inject(ContributionProvider) @named(BackendApplicationContribution)
         protected readonly contributionsProvider: ContributionProvider<BackendApplicationContribution>,
@@ -195,9 +197,8 @@ export class BackendApplication {
         await Promise.all(this.contributionsProvider.getContributions().map(async contribution => {
             if (contribution.initialize) {
                 try {
-                    await this.measure(contribution.constructor.name + '.initialize',
-                        () => contribution.initialize!()
-                    );
+                    await this.measureContribution(contribution, 'initialize',
+                        () => contribution.initialize!());
                 } catch (error) {
                     console.error('Could not initialize contribution', error);
                 }
@@ -211,6 +212,7 @@ export class BackendApplication {
 
     @postConstruct()
     protected init(): void {
+        this.settlementContext = new MeasurementContext(this.stopwatch, 'Backend', TIMER_WARNING_THRESHOLD);
         this._configured = this.configure();
     }
 
@@ -232,7 +234,8 @@ export class BackendApplication {
         await Promise.all(this.contributionsProvider.getContributions().map(async contribution => {
             if (contribution.configure) {
                 try {
-                    await contribution.configure!(this.app);
+                    await this.measureContribution(contribution, 'configure',
+                        () => contribution.configure!(this.app));
                 } catch (error) {
                     console.error('Could not configure contribution', error);
                 }
@@ -246,6 +249,8 @@ export class BackendApplication {
     }
 
     async start(port?: number, hostname?: string): Promise<http.Server | https.Server> {
+        const startupMeasurement = this.stopwatch.start('backend-startup');
+
         hostname ??= this.cliParams.hostname;
         port ??= this.cliParams.port;
 
@@ -307,15 +312,17 @@ export class BackendApplication {
         for (const contribution of this.contributionsProvider.getContributions()) {
             if (contribution.onStart) {
                 try {
-                    await this.measure(contribution.constructor.name + '.onStart',
-                        () => contribution.onStart!(server)
-                    );
+                    await this.measureContribution(contribution, 'onStart',
+                        () => contribution.onStart!(server));
                 } catch (error) {
                     console.error('Could not start contribution', error);
                 }
             }
         }
-        return this.stopwatch.startAsync('server', 'Finished starting backend application', () => deferred.promise);
+        await deferred.promise;
+        startupMeasurement.info('Backend application startup sequence completed (async work may still be pending)');
+        this.settlementContext?.armAllSettled();
+        return server;
     }
 
     protected getHttpUrl({ address, port, family }: AddressInfo, ssl?: boolean): string {
@@ -358,8 +365,18 @@ export class BackendApplication {
         next();
     }
 
+    protected async measureContribution<T>(contribution: BackendApplicationContribution, hook: string, fn: () => MaybePromise<T>): Promise<T> {
+        let innerResult: MaybePromise<T>;
+        this.settlementContext?.ensureEntry(contribution);
+        const result = await this.measure(contribution.constructor.name + '.' + hook,
+            () => (innerResult = fn())
+        );
+        this.settlementContext?.trackSettlement(contribution, innerResult!);
+        return result;
+    }
+
     protected async measure<T>(name: string, fn: () => MaybePromise<T>): Promise<T> {
-        return this.stopwatch.startAsync(name, `Backend ${name}`, fn, { thresholdMillis: TIMER_WARNING_THRESHOLD });
+        return this.stopwatch.startAsync(name, `Backend ${name}`, fn, { thresholdMillis: TIMER_WARNING_THRESHOLD, defaultLogLevel: LogLevel.DEBUG });
     }
 
     protected handleUncaughtError(error: Error): void {

package/src/node/performance/node-stopwatch.ts

@@ -23,7 +23,7 @@ export class NodeStopwatch extends Stopwatch {
 
     constructor() {
         super({
-            owner: 'backend',
+            owner: 'backend process',
             now: () => performance.now(),
         });
     }