@theia/core 1.22.1 → 1.23.0-next.26

package/src/common/performance/measurement-protocol.ts

@@ -0,0 +1,104 @@
+/********************************************************************************
+* Copyright (c) 2021 STMicroelectronics and others.
+*
+* This program and the accompanying materials are made available under the
+* terms of the Eclipse Public License 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 WITH Classpath-exception-2.0
+*******************************************************************************/
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { inject, injectable } from 'inversify';
+import { Measurement, MeasurementOptions } from './measurement';
+import { Stopwatch } from './stopwatch';
+
+export const BackendStopwatch = Symbol('BackendStopwatch');
+
+/** API path of the stopwatch service that exposes the back-end stopwatch to clients. */
+export const stopwatchPath = '/services/stopwatch';
+
+/** Token representing a remote measurement in the {@link BackendStopwatch} protocol. */
+export type RemoteMeasurement = number;
+
+export const BackendStopwatchOptions = Symbol('BackendStopwatchOptions');
+
+/**
+ * A service that exposes the back-end's {@link Stopwatch} to clients
+ * via the remote API. If you do not need this service then bind or re-bind
+ * the {@link NullBackendStopwatch} implementation to this service interface.
+ */
+export interface BackendStopwatch {
+
+    /**
+     * Create a {@link Measurement} that will compute the time that elapsed on the back-end when logged.
+     *
+     * @param name the {@link Measurement.name measurement name}
+     * @param options optional configuration of the new measurement
+     * @returns a token identifying an unique self-timing measurement relative to the back-end's timeline
+     */
+    start(name: string, options?: MeasurementOptions): Promise<RemoteMeasurement>;
+
+    /**
+     * Stop a measurement previously {@link start started} and log in the back-end a measurement of
+     * its duration relative to the back-end's timeline.
+     *
+     * @param measurement token identifying a measurement previously {@link start started}
+     * @param message a message to log
+     * @param messageArgs optional arguments to the `message`
+     */
+    stop(measurement: RemoteMeasurement, message: string, messageArgs: any[]): Promise<void>;
+
+}
+
+/**
+ * Default implementation of the (remote) back-end stopwatch service.
+ */
+@injectable()
+export class DefaultBackendStopwatch {
+
+    readonly measurements = new Map<number, Measurement>();
+
+    protected idSequence: number = 0;
+
+    @inject(Stopwatch)
+    protected readonly stopwatch: Stopwatch;
+
+    start(name: string, options?: MeasurementOptions): RemoteMeasurement {
+        const result = ++this.idSequence;
+        this.measurements.set(result, this.stopwatch.start(name, options));
+        return result;
+    }
+
+    stop(measurementToken: RemoteMeasurement, message: string, messageArgs: any[]): void {
+        const measurement = this.measurements.get(measurementToken);
+        if (measurement) {
+            this.measurements.delete(measurementToken);
+            measurement.log(message, ...messageArgs);
+        }
+    }
+
+}
+
+/**
+ * No-op implementation of the (remote) back-end stopwatch service.
+ */
+@injectable()
+export class NullBackendStopwatch implements BackendStopwatch {
+
+    start(): Promise<RemoteMeasurement> {
+        return Promise.resolve(0);
+    }
+
+    stop(): Promise<void> {
+        return Promise.resolve();
+    }
+
+}

package/src/common/performance/measurement.ts

@@ -0,0 +1,104 @@
+/********************************************************************************
+* Copyright (c) 2021 STMicroelectronics and others.
+*
+* This program and the accompanying materials are made available under the
+* terms of the Eclipse Public License 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 WITH Classpath-exception-2.0
+*******************************************************************************/
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { LogLevel } from '../logger';
+
+/**
+ * A `Measurement` counts the time elapsed between its creation when the {@link Stopwatch}
+ * is {@link Stopwatch.start started} and when it is {@link stop stopped}.
+ */
+export interface Measurement {
+    /**
+     * Compute the elapsed time, in milliseconds, if not already done (only has effect on the first invocation).
+     * A `NaN` result indicates that the watch was stopped but failed to make a measurement.
+     */
+    stop(): number;
+
+    /** The measurement name. This may show up in the performance measurement framework appropriate to the application context. */
+    name: string;
+
+    /**
+     * The elapsed time measured, if it has been {@link stop stopped} and measured, or `NaN` if the platform disabled
+     * performance measurement.
+     */
+    elapsed?: number;
+
+    /**
+     * Compute the elapsed time and log a message annotated with that timing information.
+     * The message is logged at the level determined by the {@link MeasurementOptions}.
+     *
+     * @param detail a message detailing what activity was measured
+     * @param optionalArgs optional message arguments as per the usual console API
+     */
+    log(detail: string, ...optionalArgs: any[]): void;
+
+    /**
+     * Compute the elapsed time and log a debug message annotated with that timing information.
+     *
+     * @param detail a message detailing what activity was measured
+     * @param optionalArgs optional message arguments as per the usual console API
+     */
+    debug(detail: string, ...optionalArgs: any[]): void;
+
+    /**
+     * Compute the elapsed time and log an info message annotated with that timing information.
+     *
+     * @param detail a message detailing what activity was measured
+     * @param optionalArgs optional message arguments as per the usual console API
+     */
+    info(detail: string, ...optionalArgs: any[]): void;
+
+    /**
+     * Compute the elapsed time and log a warning message annotated with that timing information.
+     *
+     * @param detail a message detailing what activity was measured
+     * @param optionalArgs optional message arguments as per the usual console API
+     */
+    warn(detail: string, ...optionalArgs: any[]): void;
+
+    /**
+     * Compute the elapsed time and log an error message annotated with that timing information.
+     *
+     * @param detail a message detailing what activity was measured
+     * @param optionalArgs optional message arguments as per the usual console API
+     */
+    error(detail: string, ...optionalArgs: any[]): void;
+}
+
+/**
+ * Optional configuration of a {@link Measurement} specified at the time of its creation.
+ */
+export interface MeasurementOptions {
+    /**
+     * A specific context of the application in which an activity was measured.
+     * Results in logs being emitted with a "[<context>]" qualified at the head.
+     */
+    context?: string;
+
+    /** An optional logging level at which to emit the log message. The default value is {@link LogLevel.INFO}. */
+    defaultLogLevel?: LogLevel;
+
+    /**
+     * Some measurements are measured against a threshold (in millis) that they should not exceed.
+     * If omitted, the implied threshold is unlimited time (no threshold).
+     *
+     * @see {@link Stopwatch.startAsync}
+     * @see {@link thresholdLogLevel}
+     */
+    thresholdMillis?: number;
+}

package/src/common/performance/stopwatch.ts

@@ -0,0 +1,157 @@
+/********************************************************************************
+* Copyright (c) 2021 STMicroelectronics and others.
+*
+* This program and the accompanying materials are made available under the
+* terms of the Eclipse Public License 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 WITH Classpath-exception-2.0
+*******************************************************************************/
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { inject, injectable } from 'inversify';
+import { ILogger, LogLevel } from '../logger';
+import { MaybePromise } from '../types';
+import { Measurement, MeasurementOptions } from './measurement';
+
+/** The default log level for measurements that are not otherwise configured with a default. */
+const DEFAULT_LOG_LEVEL = LogLevel.INFO;
+
+/**
+ * Configuration of the log messages written by a {@link Measurement}.
+ */
+interface LogOptions extends MeasurementOptions {
+    /** A function that computes the current time, in millis, since the start of the application. */
+    now: () => number;
+
+    /** An optional label for the application the start of which (in real time) is the basis of all measurements. */
+    owner?: string;
+
+    /** An optional log level to override any default or dynamic log level for a specific log message. */
+    levelOverride?: LogLevel;
+
+    /** Optional arguments to the log message. The 'optionalArgs' coming in from the {@link Measurement} API are slotted in here. */
+    arguments?: any[];
+}
+
+/**
+ * A factory of {@link Measurement}s for performance logging.
+ */
+@injectable()
+export abstract class Stopwatch {
+
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
+    protected constructor(protected readonly defaultLogOptions: LogOptions) {
+        if (!defaultLogOptions.defaultLogLevel) {
+            defaultLogOptions.defaultLogLevel = DEFAULT_LOG_LEVEL;
+        }
+    }
+
+    /**
+     * Create a {@link Measurement} that will compute its elapsed time when logged.
+     *
+     * @param name the {@link Measurement.name measurement name}
+     * @param options optional configuration of the new measurement
+     * @returns a self-timing measurement
+     */
+    public abstract start(name: string, options?: MeasurementOptions): Measurement;
+
+    /**
+     * Wrap an asynchronous function in a {@link Measurement} that logs itself on completion.
+     * If obtaining and awaiting the `computation` runs too long according to the threshold
+     * set in the `options`, then the log message is a warning, otherwise a debug log.
+     *
+     * @param name the {@link Measurement.name name of the measurement} to wrap around the function
+     * @param description a description of what the function does, to be included in the log
+     * @param computation a supplier of the asynchronous function to wrap
+     * @param options optional addition configuration as for {@link measure}
+     * @returns the wrapped `computation`
+     *
+     * @see {@link MeasurementOptions.thresholdMillis}
+     */
+    public async startAsync<T>(name: string, description: string, computation: () => MaybePromise<T>, options?: MeasurementOptions): Promise<T> {
+        const threshold = options?.thresholdMillis ?? Number.POSITIVE_INFINITY;
+
+        const measure = this.start(name, options);
+        const result = await computation();
+        if (measure.stop() > threshold) {
+            measure.warn(`${description} took longer than the expected maximum ${threshold} milliseconds`);
+        } else {
+            measure.log(description);
+        }
+        return result;
+    }
+
+    protected createMeasurement(name: string, measurement: () => number, options?: MeasurementOptions): Measurement {
+        const logOptions = this.mergeLogOptions(options);
+
+        const result: Measurement = {
+            name,
+            stop: () => {
+                if (result.elapsed === undefined) {
+                    result.elapsed = measurement();
+                }
+                return result.elapsed;
+            },
+            log: (activity: string, ...optionalArgs: any[]) => this.log(result, activity, this.atLevel(logOptions, undefined, optionalArgs)),
+            debug: (activity: string, ...optionalArgs: any[]) => this.log(result, activity, this.atLevel(logOptions, LogLevel.DEBUG, optionalArgs)),
+            info: (activity: string, ...optionalArgs: any[]) => this.log(result, activity, this.atLevel(logOptions, LogLevel.INFO, optionalArgs)),
+            warn: (activity: string, ...optionalArgs: any[]) => this.log(result, activity, this.atLevel(logOptions, LogLevel.WARN, optionalArgs)),
+            error: (activity: string, ...optionalArgs: any[]) => this.log(result, activity, this.atLevel(logOptions, LogLevel.ERROR, optionalArgs)),
+        };
+
+        return result;
+    }
+
+    protected mergeLogOptions(logOptions?: Partial<LogOptions>): LogOptions {
+        const result: LogOptions = { ...this.defaultLogOptions };
+        if (logOptions) {
+            Object.assign(result, logOptions);
+        }
+        return result;
+    }
+
+    protected atLevel(logOptions: LogOptions, levelOverride?: LogLevel, optionalArgs?: any[]): LogOptions {
+        return { ...logOptions, levelOverride, arguments: optionalArgs };
+    }
+
+    protected logLevel(elapsed: number, options?: Partial<LogOptions>): LogLevel {
+        if (options?.levelOverride) {
+            return options.levelOverride;
+        }
+
+        return options?.defaultLogLevel ?? this.defaultLogOptions.defaultLogLevel ?? DEFAULT_LOG_LEVEL;
+    }
+
+    protected log(measurement: Measurement, activity: string, options: LogOptions): void {
+        const elapsed = measurement.stop();
+        const level = this.logLevel(elapsed, options);
+
+        if (Number.isNaN(elapsed)) {
+            switch (level) {
+                case LogLevel.ERROR:
+                case LogLevel.FATAL:
+                    // Always log errors, even if NaN duration from native API preventing a measurement
+                    break;
+                default:
+                    // Measurement was prevented by native API, do not log NaN duration
+                    return;
+            }
+        }
+
+        const start = options.owner ? `${options.owner} start` : 'start';
+        const timeFromStart = `Finished ${(options.now() / 1000).toFixed(3)} s after ${start}`;
+        const whatWasMeasured = options.context ? `[${options.context}] ${activity}` : activity;
+        this.logger.log(level, `${whatWasMeasured}: ${elapsed.toFixed(1)} ms [${timeFromStart}]`, ...(options.arguments ?? []));
+    }
+
+}

package/src/common/promise-util.ts

@@ -57,6 +57,22 @@ export function timeout(ms: number, token = CancellationToken.None): Promise<voi
     return deferred.promise;
 }
 
+/**
+ * Creates a promise that is rejected after the given amount of time. A typical use case is to wait for another promise until a specified timeout using:
+ * ```
+ * Promise.race([ promiseToPerform, timeoutReject(timeout, 'Timeout error message') ]);
+ * ```
+ *
+ * @param ms timeout in milliseconds
+ * @param message error message on promise rejection
+ * @returns rejection promise
+ */
+export function timeoutReject<T>(ms: number, message?: string): Promise<T> {
+    const deferred = new Deferred<T>();
+    setTimeout(() => deferred.reject(new Error(message)), ms);
+    return deferred.promise;
+}
+
 export async function retry<T>(task: () => Promise<T>, retryDelay: number, retries: number): Promise<T> {
     let lastError: Error | undefined;
 

package/src/common/types.ts

@@ -68,8 +68,48 @@ export namespace Prioritizeable {
     }
 }
 
+export namespace ArrayUtils {
+    export interface Head<T> extends Array<T> {
+        head(): T;
+    }
+
+    export interface Tail<T> extends Array<T> {
+        tail(): T;
+    }
+
+    export interface Children<T> extends Array<T> {
+        children(): Tail<T>
+    }
+
+    export const TailImpl = {
+        tail<T>(this: Array<T>): T {
+            return this[this.length - 1];
+        },
+    };
+
+    export const HeadAndChildrenImpl = {
+        head<T>(this: Array<T>): T {
+            return this[0];
+        },
+
+        children<T>(this: Array<T>): Tail<T> {
+            return Object.assign(this.slice(1), TailImpl);
+        }
+    };
+
+    export interface HeadAndTail<T> extends Head<T>, Tail<T>, Children<T> { }
+
+    export function asTail<T>(array: Array<T>): Tail<T> {
+        return Object.assign(array, TailImpl);
+    }
+
+    export function asHeadAndTail<T>(array: Array<T>): HeadAndTail<T> {
+        return Object.assign(array, HeadAndChildrenImpl, TailImpl);
+    }
+}
+
 /**
- * Throws when called and statically make sure that all variants of a type were consumed.
+ * Throws when called and statically makes sure that all variants of a type were consumed.
  */
 export function unreachable(_never: never, message: string = 'unhandled case'): never {
     throw new Error(message);

package/src/electron-browser/menu/electron-menu-contribution.ts

@@ -267,7 +267,7 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
         });
 
         registry.registerCommand(ElectronCommands.RELOAD, {
-            execute: () => currentWindow.reload()
+            execute: () => this.windowService.reload()
         });
         registry.registerCommand(ElectronCommands.CLOSE_WINDOW, {
             execute: () => currentWindow.close()

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

@@ -16,7 +16,7 @@
 
 import { inject, injectable, named } from 'inversify';
 import * as electronRemoteMain from '../../electron-shared/@electron/remote/main';
-import { screen, globalShortcut, ipcMain, app, BrowserWindow, BrowserWindowConstructorOptions, Event as ElectronEvent } from '../../electron-shared/electron';
+import { screen, ipcMain, app, BrowserWindow, BrowserWindowConstructorOptions, Event as ElectronEvent } from '../../electron-shared/electron';
 import * as path from 'path';
 import { Argv } from 'yargs';
 import { AddressInfo } from 'net';
@@ -266,7 +266,6 @@ export class ElectronMainApplication {
         electronWindow.setMenuBarVisibility(false);
         this.attachReadyToShow(electronWindow);
         this.attachSaveWindowState(electronWindow);
-        this.attachGlobalShortcuts(electronWindow);
         this.restoreMaximizedState(electronWindow, options);
         this.attachCloseListeners(electronWindow, options);
         electronRemoteMain.enable(electronWindow.webContents);
@@ -445,26 +444,6 @@ export class ElectronMainApplication {
         ).sort().join('-');
     }
 
-    /**
-     * Catch certain keybindings to prevent reloading the window using keyboard shortcuts.
-     */
-    protected attachGlobalShortcuts(electronWindow: BrowserWindow): void {
-        const handler = this.config.electron?.disallowReloadKeybinding
-            ? () => { }
-            : () => this.reload(electronWindow);
-        const accelerators = ['CmdOrCtrl+R', 'F5'];
-        electronWindow.on('focus', () => {
-            for (const accelerator of accelerators) {
-                globalShortcut.register(accelerator, handler);
-            }
-        });
-        electronWindow.on('blur', () => {
-            for (const accelerator of accelerators) {
-                globalShortcut.unregister(accelerator);
-            }
-        });
-    }
-
     protected restoreMaximizedState(electronWindow: BrowserWindow, options: TheiaBrowserWindowOptions): void {
         if (options.isMaximized) {
             electronWindow.maximize();

package/src/node/backend-application-module.ts

@@ -35,6 +35,7 @@ import { KeytarServiceImpl } from './keytar-server';
 import { ContributionFilterRegistry, ContributionFilterRegistryImpl } from '../common/contribution-filter';
 import { EnvironmentUtils } from './environment-utils';
 import { ProcessUtils } from './process-utils';
+import { bindNodeStopwatch, bindBackendStopwatchServer } from './performance';
 
 decorate(injectable(), ApplicationPackage);
 
@@ -109,4 +110,7 @@ export const backendApplicationModule = new ContainerModule(bind => {
 
     bind(EnvironmentUtils).toSelf().inSingletonScope();
     bind(ProcessUtils).toSelf().inSingletonScope();
+
+    bindNodeStopwatch(bind);
+    bindBackendStopwatchServer(bind);
 });

package/src/node/backend-application.ts

@@ -20,9 +20,8 @@ import * as https from 'https';
 import * as express from 'express';
 import * as yargs from 'yargs';
 import * as fs from 'fs-extra';
-import { performance, PerformanceObserver } from 'perf_hooks';
 import { inject, named, injectable, postConstruct } from 'inversify';
-import { ContributionProvider, MaybePromise } from '../common';
+import { ContributionProvider, MaybePromise, Stopwatch } from '../common';
 import { CliContribution } from './cli';
 import { Deferred } from '../common/promise-util';
 import { environment } from '../common/index';
@@ -152,13 +151,13 @@ export class BackendApplication {
     @inject(ProcessUtils)
     protected readonly processUtils: ProcessUtils;
 
-    private readonly _performanceObserver: PerformanceObserver;
+    @inject(Stopwatch)
+    protected readonly stopwatch: Stopwatch;
 
     constructor(
         @inject(ContributionProvider) @named(BackendApplicationContribution)
         protected readonly contributionsProvider: ContributionProvider<BackendApplicationContribution>,
-        @inject(BackendApplicationCliContribution) protected readonly cliParams: BackendApplicationCliContribution
-    ) {
+        @inject(BackendApplicationCliContribution) protected readonly cliParams: BackendApplicationCliContribution) {
         process.on('uncaughtException', error => {
             if (error) {
                 console.error('Uncaught Exception: ', error.toString());
@@ -185,23 +184,6 @@ export class BackendApplication {
         process.on('SIGINT', signalHandler);
         // Handles `kill pid`.
         process.on('SIGTERM', signalHandler);
-
-        // Create performance observer
-        this._performanceObserver = new PerformanceObserver(list => {
-            for (const item of list.getEntries()) {
-                const contribution = `Backend ${item.name}`;
-                if (item.duration > TIMER_WARNING_THRESHOLD) {
-                    console.warn(`${contribution} is slow, took: ${item.duration.toFixed(1)} ms`);
-                } else {
-                    console.debug(`${contribution} took: ${item.duration.toFixed(1)} ms`);
-                }
-            }
-        });
-        this._performanceObserver.observe({
-            entryTypes: ['measure']
-        });
-
-        this.initialize();
     }
 
     protected async initialize(): Promise<void> {
@@ -220,6 +202,10 @@ export class BackendApplication {
 
     @postConstruct()
     protected async configure(): Promise<void> {
+        // Do not await the initialization because contributions are expected to handle
+        // concurrent initialize/configure in undefined order if they provide both
+        this.initialize();
+
         this.app.get('*.js', this.serveGzipped.bind(this, 'text/javascript'));
         this.app.get('*.js.map', this.serveGzipped.bind(this, 'application/json'));
         this.app.get('*.css', this.serveGzipped.bind(this, 'text/css'));
@@ -309,7 +295,7 @@ export class BackendApplication {
                 }
             }
         }
-        return deferred.promise;
+        return this.stopwatch.startAsync('server', 'Finished starting backend application', () => deferred.promise);
     }
 
     protected onStop(): void {
@@ -324,7 +310,6 @@ export class BackendApplication {
             }
         }
         console.info('<<< All backend contributions have been stopped.');
-        this._performanceObserver.disconnect();
         this.processUtils.terminateProcessTree(process.pid);
     }
 
@@ -347,15 +332,7 @@ export class BackendApplication {
     }
 
     protected async measure<T>(name: string, fn: () => MaybePromise<T>): Promise<T> {
-        const startMark = name + '-start';
-        const endMark = name + '-end';
-        performance.mark(startMark);
-        const result = await fn();
-        performance.mark(endMark);
-        performance.measure(name, startMark, endMark);
-        // Observer should immediately log the measurement, so we can clear it
-        performance.clearMarks(name);
-        return result;
+        return this.stopwatch.startAsync(name, `Backend ${name}`, fn, { thresholdMillis: TIMER_WARNING_THRESHOLD });
     }
 
 }

package/src/node/messaging/ipc-connection-provider.ts

@@ -17,7 +17,7 @@
 import * as cp from 'child_process';
 import * as path from 'path';
 import { injectable, inject } from 'inversify';
-import { Trace, IPCMessageReader, IPCMessageWriter, createMessageConnection, MessageConnection, Message } from 'vscode-ws-jsonrpc';
+import { Trace, Tracer, IPCMessageReader, IPCMessageWriter, createMessageConnection, MessageConnection, Message } from 'vscode-ws-jsonrpc';
 import { ILogger, ConnectionErrorHandler, DisposableCollection, Disposable } from '../../common';
 import { createIpcEnv } from './ipc-protocol';
 
@@ -83,10 +83,14 @@ export class IPCConnectionProvider {
             info: (message: string) => this.logger.info(`[${options.serverName}: ${childProcess.pid}] ${message}`),
             log: (message: string) => this.logger.info(`[${options.serverName}: ${childProcess.pid}] ${message}`)
         });
-        const traceVerbosity = this.logger.isDebug() ? Trace.Verbose : Trace.Off;
-        connection.trace(traceVerbosity, {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            log: (message: any, data?: string) => this.logger.debug(`[${options.serverName}: ${childProcess.pid}] ${message}` + (typeof data === 'string' ? ' ' + data : ''))
+        const tracer: Tracer = {
+            log: (message: unknown, data?: string) => this.logger.debug(`[${options.serverName}: ${childProcess.pid}] ${message}` + (typeof data === 'string' ? ' ' + data : ''))
+        };
+        connection.trace(Trace.Verbose, tracer);
+        this.logger.isDebug().then(isDebug => {
+            if (!isDebug) {
+                connection.trace(Trace.Off, tracer);
+            }
         });
         return connection;
     }

package/src/node/performance/index.ts

@@ -0,0 +1,18 @@
+/********************************************************************************
+ * Copyright (C) 2021 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+export * from './node-stopwatch';
+export * from './measurement-backend-bindings';