@theia/plugin-ext 1.58.2 → 1.59.0-next.62

package/src/plugin/notebook/notebook-kernels.ts

@@ -36,6 +36,7 @@ import { toUriComponents } from '../../main/browser/hierarchy/hierarchy-types-co
 import type * as theia from '@theia/plugin';
 import { WebviewsExtImpl } from '../webviews';
 import { WorkspaceExtImpl } from '../workspace';
+import { PluginLogger } from '../logger';
 
 interface KernelData {
     extensionId: string;
@@ -53,6 +54,8 @@ export class NotebookKernelsExtImpl implements NotebookKernelsExt {
 
     private readonly proxy: NotebookKernelsMain;
 
+    private readonly logger: PluginLogger;
+
     private kernelDetectionTasks = new Map<number, theia.NotebookControllerDetectionTask>();
     private currentKernelDetectionTaskHandle = 0;
 
@@ -70,6 +73,7 @@ export class NotebookKernelsExtImpl implements NotebookKernelsExt {
         workspace: WorkspaceExtImpl
     ) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.NOTEBOOK_KERNELS_MAIN);
+        this.logger = new PluginLogger(rpc, 'notebook');
 
         // call onDidChangeSelection for all kernels after trust is granted to inform extensions they can set the kernel as assoiciated
         // the jupyter extension for example does not set kernel association after trust is granted
@@ -97,9 +101,9 @@ export class NotebookKernelsExtImpl implements NotebookKernelsExt {
         const handle = this.currentHandle++;
         const that = this;
 
-        console.debug(`NotebookController[${handle}], CREATED by ${extension.id}, ${id}`);
+        this.logger.debug(`NotebookController[${handle}], CREATED by ${extension.id}, ${id}`);
 
-        const defaultExecuteHandler = () => console.warn(`NO execute handler from notebook controller '${data.id}' of extension: '${extension.id}'`);
+        const defaultExecuteHandler = () => this.logger.warn(`NO execute handler from notebook controller '${data.id}' of extension: '${extension.id}'`);
 
         let isDisposed = false;
         const commandDisposables = new DisposableCollection();
@@ -122,7 +126,7 @@ export class NotebookKernelsExtImpl implements NotebookKernelsExt {
 
         this.proxy.$addKernel(handle, data).catch(err => {
             // this can happen when a kernel with that ID is already registered
-            console.log(err);
+            this.logger.info(err);
             isDisposed = true;
         });
 
@@ -206,7 +210,7 @@ export class NotebookKernelsExtImpl implements NotebookKernelsExt {
                     throw new Error('notebook controller is DISPOSED');
                 }
                 if (!associatedNotebooks.has(cell.notebook.uri.toString())) {
-                    console.debug(`NotebookController[${handle}] NOT associated to notebook, associated to THESE notebooks:`,
+                    that.logger.debug(`NotebookController[${handle}] NOT associated to notebook, associated to THESE notebooks:`,
                         Array.from(associatedNotebooks.keys()).map(u => u.toString()));
                     throw new Error(`notebook controller is NOT associated to notebook: ${cell.notebook.uri.toString()}`);
                 }
@@ -214,7 +218,7 @@ export class NotebookKernelsExtImpl implements NotebookKernelsExt {
             },
             dispose: () => {
                 if (!isDisposed) {
-                    console.debug(`NotebookController[${handle}], DISPOSED`);
+                    that.logger.debug(`NotebookController[${handle}] DISPOSED`);
                     isDisposed = true;
                     this.kernelData.delete(handle);
                     commandDisposables.dispose();
@@ -257,7 +261,7 @@ export class NotebookKernelsExtImpl implements NotebookKernelsExt {
         if (this.activeExecutions.has(cellObj.uri.toString())) {
             throw new Error(`duplicate execution for ${cellObj.uri}`);
         }
-        const execution = new NotebookCellExecutionTask(controllerId, cellObj, this.proxy);
+        const execution = new NotebookCellExecutionTask(controllerId, cellObj, this.proxy, this.logger);
         this.activeExecutions.set(cellObj.uri.toString(), execution);
         const listener = execution.onDidChangeState(() => {
             if (execution.state === NotebookCellExecutionTaskState.Resolved) {
@@ -318,7 +322,7 @@ export class NotebookKernelsExtImpl implements NotebookKernelsExt {
             } else {
                 obj.associatedNotebooks.delete(notebook.uri.toString());
             }
-            console.debug(`NotebookController[${handle}] ASSOCIATE notebook`, notebook.uri.toString(), selected);
+            this.logger.debug(`NotebookController[${handle}] ASSOCIATE notebook`, notebook.uri.toString(), selected);
             // send event
             obj.onDidChangeSelection.fire({
                 selected: selected,
@@ -344,10 +348,13 @@ export class NotebookKernelsExtImpl implements NotebookKernelsExt {
         }
 
         try {
-            console.debug(`NotebookController[${handle}] EXECUTE cells`, document.uri.toString(), cells.length);
+            this.logger.debug(`NotebookController[${handle}] EXECUTE cells`, {
+                notebook: document.uri.toString(),
+                cells: cells.map(e => e.index)
+            });
             await obj.controller.executeHandler.call(obj.controller, cells, document.apiNotebook, obj.controller);
         } catch (err) {
-            console.error(`NotebookController[${handle}] execute cells FAILED`, err);
+            this.logger.error(`NotebookController[${handle}] EXECUTE cells FAILED`, err);
         }
 
     }
@@ -428,12 +435,14 @@ class NotebookCellExecutionTask implements Disposable {
     constructor(
         controllerId: string,
         private readonly cell: Cell,
-        private readonly proxy: NotebookKernelsMain
+        private readonly proxy: NotebookKernelsMain,
+        private readonly logger: PluginLogger
     ) {
         this.collector = new TimeoutBasedCollector(10, updates => this.update(updates));
 
         this.executionOrder = cell.internalMetadata.executionOrder;
         this.proxy.$createExecution(this._handle, controllerId, this.cell.notebookDocument.uri, this.cell.handle);
+        this.logger.debug(`NotebookCellExecutionTask[${this._handle}] CREATED`, { controllerId, cell: this.cell.uri.toString() });
     }
 
     cancel(): void {
@@ -487,18 +496,21 @@ class NotebookCellExecutionTask implements Disposable {
     private async updateOutputs(outputs: NotebookCellOutput | NotebookCellOutput[], cell: theia.NotebookCell | undefined, append: boolean): Promise<void> {
         const handle = this.cellIndexToHandle(cell);
         const outputDtos = this.validateAndConvertOutputs(Array.isArray(outputs) ? outputs : [outputs]);
+        this.logger.debug(`NotebookCellExecutionTask[${this._handle}] received new outputs from plugin`, { append, outputs: outputDtos });
         return this.updateSoon(
             {
                 editType: CellExecutionUpdateType.Output,
                 cellHandle: handle,
                 append,
                 outputs: outputDtos
-            });
+            }
+        );
     }
 
     private async updateOutputItems(items: theia.NotebookCellOutputItem | theia.NotebookCellOutputItem[],
         output: theia.NotebookCellOutput, append: boolean): Promise<void> {
         items = NotebookCellOutputConverter.ensureUniqueMimeTypes(Array.isArray(items) ? items : [items], true);
+        this.logger.debug(`NotebookCellExecutionTask[${this._handle}] received new outputs from plugin`, { append, items });
         return this.updateSoon({
             editType: CellExecutionUpdateType.OutputItems,
             items: items.map(NotebookCellOutputItem.from),

package/src/plugin/notebook/notebooks.ts

@@ -37,6 +37,7 @@ import { NotebookEditor } from './notebook-editor';
 import { EditorsAndDocumentsExtImpl } from '../editors-and-documents';
 import { DocumentsExtImpl } from '../documents';
 import { CellUri, NotebookCellModelResource, NotebookModelResource } from '@theia/notebook/lib/common';
+import { PluginLogger } from '../logger';
 
 export class NotebooksExtImpl implements NotebooksExt {
 
@@ -68,9 +69,10 @@ export class NotebooksExtImpl implements NotebooksExt {
     private readonly editors = new Map<string, NotebookEditor>();
     private statusBarRegistry = new Cache<Disposable>('NotebookCellStatusBarCache');
 
-    private notebookProxy: NotebooksMain;
-    private notebookDocumentsProxy: NotebookDocumentsMain;
-    private notebookEditors: NotebookEditorsMain;
+    private readonly notebookProxy: NotebooksMain;
+    private readonly notebookDocumentsProxy: NotebookDocumentsMain;
+    private readonly notebookEditors: NotebookEditorsMain;
+    private readonly logger: PluginLogger;
 
     constructor(
         rpc: RPCProtocol,
@@ -82,6 +84,7 @@ export class NotebooksExtImpl implements NotebooksExt {
         this.notebookProxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.NOTEBOOKS_MAIN);
         this.notebookDocumentsProxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.NOTEBOOK_DOCUMENTS_MAIN);
         this.notebookEditors = rpc.getProxy(PLUGIN_RPC_CONTEXT.NOTEBOOK_EDITORS_MAIN);
+        this.logger = new PluginLogger(rpc, 'notebook');
 
         commands.registerArgumentProcessor({
             processArgument: arg => {
@@ -254,7 +257,7 @@ export class NotebooksExtImpl implements NotebooksExt {
                 const uri = TheiaURI.from(modelData.uri);
 
                 if (this.documents.has(uri.toString())) {
-                    throw new Error(`adding EXISTING notebook ${uri} `);
+                    throw new Error(`cannot add EXISTING notebook ${uri}`);
                 }
 
                 const document = new NotebookDocument(
@@ -334,7 +337,7 @@ export class NotebooksExtImpl implements NotebooksExt {
         } else if (delta.newActiveEditor) {
             const activeEditor = this.editors.get(delta.newActiveEditor);
             if (!activeEditor) {
-                console.error(`FAILED to find active notebook editor ${delta.newActiveEditor}`);
+                this.logger.error(`FAILED to find active notebook editor '${delta.newActiveEditor}'.`);
             }
             this.activeNotebookEditor = this.editors.get(delta.newActiveEditor);
             this.onDidChangeActiveNotebookEditorEmitter.fire(this.activeNotebookEditor?.apiEditor);

package/src/plugin/plugin-context.ts

@@ -287,6 +287,7 @@ import { NotebookEditorsExtImpl } from './notebook/notebook-editors';
 import { TestingExtImpl } from './tests';
 import { UriExtImpl } from './uri-ext';
 import { isObject } from '@theia/core';
+import { PluginLogger } from './logger';
 
 export function createAPIObject<T extends Object>(rawObject: T): T {
     return new Proxy(rawObject, {
@@ -353,6 +354,8 @@ export function createAPIFactory(
     const uriExt = rpc.set(MAIN_RPC_CONTEXT.URI_EXT, new UriExtImpl(rpc));
     rpc.set(MAIN_RPC_CONTEXT.DEBUG_EXT, debugExt);
 
+    const commandLogger = new PluginLogger(rpc, 'commands-plugin');
+
     return function (plugin: InternalPlugin): typeof theia {
         const authentication: typeof theia.authentication = {
             registerAuthenticationProvider(id: string, label: string, provider: theia.AuthenticationProvider, options?: theia.AuthenticationProviderOptions): theia.Disposable {
@@ -393,7 +396,7 @@ export function createAPIFactory(
                 const internalHandler = (...args: any[]): any => {
                     const activeTextEditor = editors.getActiveEditor();
                     if (!activeTextEditor) {
-                        console.warn('Cannot execute ' + command + ' because there is no active text editor.');
+                        commandLogger.warn('Cannot execute ' + command + ' because there is no active text editor.');
                         return undefined;
                     }
 
@@ -402,10 +405,10 @@ export function createAPIFactory(
                         handler.apply(thisArg, args);
                     }).then(result => {
                         if (!result) {
-                            console.warn('Edits from command ' + command + ' were not applied.');
+                            commandLogger.warn('Edits from command ' + command + ' were not applied.');
                         }
                     }, err => {
-                        console.warn('An error occurred while running command ' + command, err);
+                        commandLogger.warn('An error occurred while running command ' + command, err);
                     });
                 };
                 return commandIsDeclaredInPackage(command, plugin.rawModel)

package/src/plugin/plugin-manager.ts

@@ -47,6 +47,7 @@ import { URI as Uri } from './types-impl';
 import { InternalSecretsExt, SecretStorageExt } from '../plugin/secrets-ext';
 import { PluginExt } from './plugin-context';
 import { Deferred } from '@theia/core/lib/common/promise-util';
+import { PluginLogger } from './logger';
 
 export interface PluginHost {
 
@@ -120,6 +121,7 @@ export abstract class AbstractPluginManagerExtImpl<P extends Record<string, any>
     private onDidChangeEmitter = new Emitter<void>();
     private messageRegistryProxy: MessageRegistryMain;
     private notificationMain: NotificationMain;
+    private logger: PluginLogger;
 
     protected jsonValidation: PluginJsonValidationContribution[] = [];
     protected pluginKind = ExtensionKind.UI;
@@ -129,6 +131,7 @@ export abstract class AbstractPluginManagerExtImpl<P extends Record<string, any>
     initialize(): void {
         this.messageRegistryProxy = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.MESSAGE_REGISTRY_MAIN);
         this.notificationMain = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.NOTIFICATION_MAIN);
+        this.logger = new PluginLogger(this.rpc, 'plugin-manager');
     }
 
     setPluginHost(pluginHost: PluginHost): void {
@@ -176,7 +179,7 @@ export abstract class AbstractPluginManagerExtImpl<P extends Record<string, any>
                 result = plugin.stopFn();
             } catch (e) {
                 if (!options.terminating) {
-                    console.error(`[${id}]: failed to stop:`, e);
+                    this.logger.error(`[${id}]: failed to stop:`, e);
                 }
             }
         }
@@ -188,7 +191,7 @@ export abstract class AbstractPluginManagerExtImpl<P extends Record<string, any>
                     subscription.dispose();
                 } catch (e) {
                     if (!options.terminating) {
-                        console.error(`[${id}]: failed to dispose subscription:`, e);
+                        this.logger.error(`[${id}]: failed to dispose subscription:`, e);
                     }
                 }
             }
@@ -198,7 +201,7 @@ export abstract class AbstractPluginManagerExtImpl<P extends Record<string, any>
             await result;
         } catch (e) {
             if (!options.terminating) {
-                console.error(`[${id}]: failed to stop:`, e);
+                this.logger.error(`[${id}]: failed to stop:`, e);
             }
         }
     }
@@ -248,7 +251,9 @@ export abstract class AbstractPluginManagerExtImpl<P extends Record<string, any>
             this.setActivation(`onPlugin:${plugin.model.id}`, activation);
             const unsupportedActivationEvents = activationEvents.filter(e => !this.isSupportedActivationEvent(e));
             if (unsupportedActivationEvents.length) {
-                console.warn(`Unsupported activation events: ${unsupportedActivationEvents.join(', ')}, please open an issue: https://github.com/eclipse-theia/theia/issues/new`);
+                this.logger.warn(
+                    `Unsupported activation events: ${unsupportedActivationEvents.join(', ')}, please open an issue: https://github.com/eclipse-theia/theia/issues/new`
+                );
             }
             for (let activationEvent of activationEvents) {
                 if (activationEvent === 'onUri') {
@@ -293,10 +298,10 @@ export abstract class AbstractPluginManagerExtImpl<P extends Record<string, any>
                             if (dependency) {
                                 const loadedSuccessfully = await this.loadPlugin(dependency, configStorage, visited);
                                 if (!loadedSuccessfully) {
-                                    throw new Error(`Dependent extension '${dependency.model.displayName || dependency.model.id}' failed to activate.`);
+                                    throw new Error(`Dependent plugin '${dependency.model.displayName || dependency.model.id}' failed to activate.`);
                                 }
                             } else {
-                                throw new Error(`Dependent extension '${dependencyId}' is not installed.`);
+                                throw new Error(`Dependent plugin '${dependencyId}' is not installed.`);
                             }
                         }
                     }
@@ -307,9 +312,9 @@ export abstract class AbstractPluginManagerExtImpl<P extends Record<string, any>
                     await this.startPlugin(plugin, configStorage, pluginMain);
                     return true;
                 } catch (err) {
-                    const message = `Activating extension '${plugin.model.displayName || plugin.model.name}' failed:`;
+                    const message = `Activating plugin '${plugin.model.displayName || plugin.model.name}' failed:`;
                     this.messageRegistryProxy.$showMessage(MainMessageType.Error, message + ' ' + err.message, {}, []);
-                    console.error(message, err);
+                    this.logger.error(message, err);
                     return false;
                 } finally {
                     this.notificationMain.$stopProgress(progressId);
@@ -410,11 +415,11 @@ export abstract class AbstractPluginManagerExtImpl<P extends Record<string, any>
         if (typeof pluginMain[plugin.lifecycle.startMethod] === 'function') {
             await this.localization.initializeLocalizedMessages(plugin, this.envExt.language);
             const pluginExport = await pluginMain[plugin.lifecycle.startMethod].apply(getGlobal(), [pluginContext]);
-            console.log(`calling activation function on ${id}`);
+            this.logger.debug(`Calling activation function on plugin ${id}`);
             this.activatedPlugins.set(plugin.model.id, new ActivatedPlugin(pluginContext, pluginExport, stopFn));
         } else {
             // https://github.com/TypeFox/vscode/blob/70b8db24a37fafc77247de7f7cb5bb0195120ed0/src/vs/workbench/api/common/extHostExtensionService.ts#L400-L401
-            console.log(`plugin ${id}, ${plugin.lifecycle.startMethod} method is undefined so the module is the extension's exports`);
+            this.logger.debug(`Plugin ${id}, ${plugin.lifecycle.startMethod} method is undefined so the module is the extension's exports`);
             this.activatedPlugins.set(plugin.model.id, new ActivatedPlugin(pluginContext, pluginMain));
         }
     }

package/src/plugin/uri-ext.ts

@@ -31,7 +31,6 @@ export class UriExtImpl implements UriExt {
 
     constructor(readonly rpc: RPCProtocol) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.URI_MAIN);
-        console.log(this.proxy);
     }
 
     registerUriHandler(handler: theia.UriHandler, plugin: PluginInfo): theia.Disposable {

package/src/plugin/workspace.ts

@@ -44,6 +44,7 @@ import { MessageRegistryExt } from './message-registry';
 import * as Converter from './type-converters';
 import { FileStat } from '@theia/filesystem/lib/common/files';
 import { isUndefinedOrNull, isUndefined } from '../common/types';
+import { PluginLogger } from './logger';
 
 @injectable()
 export class WorkspaceExtImpl implements WorkspaceExt {
@@ -58,6 +59,7 @@ export class WorkspaceExtImpl implements WorkspaceExt {
     protected messageService: MessageRegistryExt;
 
     private proxy: WorkspaceMain;
+    private logger: PluginLogger;
 
     private workspaceFoldersChangedEmitter = new Emitter<theia.WorkspaceFoldersChangeEvent>();
     public readonly onDidChangeWorkspaceFolders: Event<theia.WorkspaceFoldersChangeEvent> = this.workspaceFoldersChangedEmitter.event;
@@ -77,6 +79,7 @@ export class WorkspaceExtImpl implements WorkspaceExt {
     @postConstruct()
     initialize(): void {
         this.proxy = this.rpc.getProxy(Ext.WORKSPACE_MAIN);
+        this.logger = new PluginLogger(this.rpc, 'workspace');
     }
 
     get rootPath(): string | undefined {
@@ -267,7 +270,7 @@ export class WorkspaceExtImpl implements WorkspaceExt {
             throw new Error(`Text Content Document Provider for scheme '${scheme}' is already registered`);
         } else if (this.documentContentProviders.has(scheme)) {
             // TODO: we should be able to handle multiple registrations, but for now we should ensure that it doesn't crash plugin activation.
-            console.warn(`Repeat registration of TextContentDocumentProvider for scheme '${scheme}'. This registration will be ignored.`);
+            this.logger.warn(`Repeat registration of TextContentDocumentProvider for scheme '${scheme}'. This registration will be ignored.`);
             return { dispose: () => { } };
         }
 
@@ -472,7 +475,7 @@ export class WorkspaceExtImpl implements WorkspaceExt {
 
         this.canonicalUriProviders.set(scheme, provider);
         this.proxy.$registerCanonicalUriProvider(scheme).catch(e => {
-            console.error(`Canonical URI provider for scheme: '${scheme}' already exists globally`);
+            this.logger.error(`Canonical URI provider for scheme: '${scheme}' already exists globally`);
             this.canonicalUriProviders.delete(scheme);
         });
         const result = Disposable.create(() => { this.proxy.$unregisterCanonicalUriProvider(scheme); });
@@ -481,7 +484,7 @@ export class WorkspaceExtImpl implements WorkspaceExt {
 
     $disposeCanonicalUriProvider(scheme: string): void {
         if (!this.canonicalUriProviders.delete(scheme)) {
-            console.warn(`No canonical uri provider registered for '${scheme}'`);
+            this.logger.warn(`diposeCanonicalUriProvider: No canonical uri provider registered for '${scheme}'`);
         }
     }
 
@@ -494,7 +497,7 @@ export class WorkspaceExtImpl implements WorkspaceExt {
         const parsed = URI.parse(uri);
         const provider = this.canonicalUriProviders.get(parsed.scheme);
         if (!provider) {
-            console.warn(`No canonical uri provider registered for '${parsed.scheme}'`);
+            this.logger.warn(`provideCanonicalUri: No canonical uri provider registered for '${parsed.scheme}'`);
             return undefined;
         }
         const result = await provider.provideCanonicalUri(parsed, { targetScheme: targetScheme }, token);