@theia/plugin-ext 1.76.0-next.4 → 1.76.0-next.42

package/src/main/browser/languages-main.spec.ts

@@ -0,0 +1,101 @@
+// *****************************************************************************
+// Copyright (C) 2026 JuliaHub, Inc. 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+// `languages-main` transitively pulls in Monaco and several frontend modules that touch `document`
+// at module-load time.
+const disableJSDOM = enableJSDOM();
+import { expect } from 'chai';
+import * as monaco from '@theia/monaco-editor-core';
+import { mainWindow } from '@theia/monaco-editor-core/esm/vs/base/browser/window';
+import { URI } from '@theia/core/lib/common/uri';
+import { expectThrowsAsync } from '@theia/core/lib/common/test/expect';
+import { CellEditType, CellUri } from '@theia/notebook/lib/common';
+import { CellEditOperation } from '@theia/notebook/lib/browser/notebook-types';
+import type { NotebookModel } from '@theia/notebook/lib/browser/view-model/notebook-model';
+import { LanguagesMainImpl } from './languages-main';
+
+after(() => disableJSDOM());
+
+const notebookUri = new URI('file:///notebook.ipynb');
+const cellHandle = 3;
+const cellComponents = CellUri.generate(notebookUri, cellHandle).toComponents();
+
+type FakeNotebookModel = Pick<NotebookModel, 'getCellIndexByHandle' | 'applyEdits'> & {
+    edits: CellEditOperation[][];
+};
+
+function createNotebookModel(handles: number[]): FakeNotebookModel {
+    const edits: CellEditOperation[][] = [];
+    return {
+        edits,
+        getCellIndexByHandle: handle => handles.indexOf(handle),
+        applyEdits: applied => { edits.push(applied); }
+    };
+}
+
+/**
+ * Bypasses the constructor's RPC/container wiring.
+ */
+function createLanguagesMain(notebook?: FakeNotebookModel): LanguagesMainImpl {
+    const languagesMain = Object.create(LanguagesMainImpl.prototype) as LanguagesMainImpl;
+    (languagesMain as unknown as Record<string, unknown>).notebookService = {
+        getNotebookEditorModel: (uri: URI) => uri.toString() === notebookUri.toString() ? notebook : undefined
+    };
+    return languagesMain;
+}
+
+describe('LanguagesMainImpl#$changeLanguage', () => {
+
+    before(() => {
+        // Resolving a language id boots Monaco's standalone services, whose theme service reaches for
+        // DOM APIs JSDOM does not provide. Monaco captures its window at module load.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (global as any).CSS ??= { escape: (value: string) => value };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (mainWindow as any).matchMedia ??= () => ({ matches: false, addEventListener: () => { }, removeEventListener: () => { } });
+        monaco.languages.register({ id: 'julia' });
+    });
+
+    it('applies a cell language edit for a notebook cell', async () => {
+        const notebook = createNotebookModel([1, 2, cellHandle]);
+        const languagesMain = createLanguagesMain(notebook);
+
+        await languagesMain.$changeLanguage(cellComponents, 'julia');
+
+        expect(notebook.edits).to.deep.equal([[{ editType: CellEditType.CellLanguage, index: 2, language: 'julia' }]]);
+    });
+
+    it('rejects for a cell of a notebook that is not open', async () => {
+        const languagesMain = createLanguagesMain();
+
+        await expectThrowsAsync(languagesMain.$changeLanguage(cellComponents, 'julia'), 'Invalid uri');
+    });
+
+    it('rejects for a cell handle the notebook does not know', async () => {
+        const languagesMain = createLanguagesMain(createNotebookModel([1, 2]));
+
+        await expectThrowsAsync(languagesMain.$changeLanguage(cellComponents, 'julia'), 'Invalid uri');
+    });
+
+    it('rejects an unknown language id before touching the notebook', async () => {
+        const notebook = createNotebookModel([cellHandle]);
+        const languagesMain = createLanguagesMain(notebook);
+
+        await expectThrowsAsync(languagesMain.$changeLanguage(cellComponents, 'no-such-language'), /Unknown language ID/);
+        expect(notebook.edits).to.be.empty;
+    });
+});

package/src/main/browser/languages-main.ts

@@ -88,6 +88,8 @@ import { CodeActionTriggerKind } from '../../plugin/types-impl';
 import { IReadonlyVSDataTransfer } from '@theia/monaco-editor-core/esm/vs/base/common/dataTransfer';
 import { FileUploadService } from '@theia/filesystem/lib/common/upload/file-upload';
 import { ILogger } from '@theia/core';
+import { NotebookService } from '@theia/notebook/lib/browser';
+import { CellEditType, CellUri } from '@theia/notebook/lib/common';
 
 @injectable()
 export class LanguagesMainImpl implements LanguagesMain, Disposable {
@@ -110,6 +112,9 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     @inject(FileUploadService)
     protected readonly fileUploadService: FileUploadService;
 
+    @inject(NotebookService)
+    protected readonly notebookService: NotebookService;
+
     @inject(ILogger) @named('plugin-ext:LanguagesMainImpl')
     protected readonly logger: ILogger;
 
@@ -129,18 +134,35 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         return Promise.resolve(monaco.languages.getLanguages().map(l => l.id));
     }
 
-    $changeLanguage(resource: UriComponents, languageId: string): Promise<void> {
-        const uri = monaco.Uri.revive(resource);
-        const model = monaco.editor.getModel(uri);
-        if (!model) {
-            return Promise.reject(new Error('Invalid uri'));
+    async $changeLanguage(resource: UriComponents, languageId: string): Promise<void> {
+        if (!monaco.languages.getEncodedLanguageId(languageId)) {
+            throw new Error(`Unknown language ID: ${languageId}`);
         }
-        const langId = monaco.languages.getEncodedLanguageId(languageId);
-        if (!langId) {
-            return Promise.reject(new Error(`Unknown language ID: ${languageId}`));
+        const cell = CellUri.parse(URI.fromComponents(resource));
+        if (cell) {
+            this.changeCellLanguage(cell.notebook, cell.handle, languageId);
+            return;
+        }
+        const model = monaco.editor.getModel(monaco.Uri.revive(resource));
+        if (!model) {
+            throw new Error('Invalid uri');
         }
         monaco.editor.setModelLanguage(model, languageId);
-        return Promise.resolve(undefined);
+    }
+
+    /**
+     * The cell model owns a cell's language; kernel selection, serialization, and the cell editor all follow it.
+     */
+    protected changeCellLanguage(notebookUri: URI, handle: number, languageId: string): void {
+        const notebook = this.notebookService.getNotebookEditorModel(notebookUri);
+        if (!notebook) {
+            throw new Error('Invalid uri');
+        }
+        const index = notebook.getCellIndexByHandle(handle);
+        if (index < 0) {
+            throw new Error('Invalid uri');
+        }
+        notebook.applyEdits([{ editType: CellEditType.CellLanguage, index, language: languageId }], true);
     }
 
     protected register(handle: number, service: Disposable): void {

package/src/main/browser/main-context.ts

@@ -68,6 +68,7 @@ import { UriMainImpl } from './uri-main';
 import { LoggerMainImpl } from './logger-main';
 import { McpServerDefinitionRegistryMainImpl } from './lm-main';
 import { LanguageModelToolsMainImpl } from './lm-tool-main';
+import { TelemetryMainImpl } from './telemetry-main';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
     const loggerMain = new LoggerMainImpl(container);
@@ -215,4 +216,7 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
 
     const languageModelToolsMain = new LanguageModelToolsMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.LM_TOOLS_MAIN, languageModelToolsMain);
+
+    const telemetryMain = new TelemetryMainImpl(rpc, container);
+    rpc.set(PLUGIN_RPC_CONTEXT.TELEMETRY_MAIN, telemetryMain);
 }

package/src/main/browser/menus/vscode-theia-menu-mappings.ts

@@ -128,6 +128,11 @@ export const codeToTheiaMappings = new Map<string, MenuPath[]>([
 
 type CodeEditorWidget = EditorWidget | WebviewWidget;
 export namespace CodeEditorWidgetUtil {
+    /**
+     * The widgets `editor/title` contributions apply to. `WebviewContextKeys.getContextKeyValues` describes
+     * exactly this set; a widget admitted to the menu delegate without also being described there reads a
+     * stale `activeCustomEditorId` from the focused editor.
+     */
     export function is(arg: unknown): arg is CodeEditorWidget {
         return arg instanceof EditorWidget || arg instanceof WebviewWidget;
     }

package/src/main/browser/plugin-ext-frontend-module.ts

@@ -24,7 +24,7 @@ import {
     ViewContainerIdentifier, ViewContainer, createTreeContainer, TreeWidget, LabelProviderContribution, LabelProvider,
     UndoRedoHandler, DiffUris, Navigatable, SplitWidget,
     noopWidgetStatusBarContribution,
-    WidgetStatusBarContribution
+    WidgetStatusBarContribution, WidgetContextKeyContribution
 } from '@theia/core/lib/browser';
 import { MaybePromise, CommandContribution, ResourceResolver, bindRootContributionProvider, URI, generateUuid, PreferenceContribution, nls } from '@theia/core/lib/common';
 import { WebSocketConnectionProvider } from '@theia/core/lib/browser/messaging';
@@ -198,6 +198,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(WebviewSecondaryWindowSupport).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(WebviewSecondaryWindowSupport);
     bind(FrontendApplicationContribution).toService(WebviewContextKeys);
+    bind(WidgetContextKeyContribution).toService(WebviewContextKeys);
     bind(WidgetStatusBarContribution).toConstantValue(noopWidgetStatusBarContribution(WebviewWidget));
 
     bind(PluginCustomEditorRegistry).toSelf().inSingletonScope();

package/src/main/browser/telemetry-main.spec.ts

@@ -0,0 +1,77 @@
+// *****************************************************************************
+// Copyright (C) 2026 JuliaHub, Inc. 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 { Emitter } from '@theia/core/lib/common/event';
+import { Container } from '@theia/core/shared/inversify';
+import { TelemetryConsentProvider } from '@theia/telemetry/lib/common/telemetry-consent-provider';
+import { TelemetryLevel } from '@theia/telemetry/lib/common/telemetry-types';
+import { RPCProtocol } from '../../common/rpc-protocol';
+import { TelemetryMainImpl } from './telemetry-main';
+
+describe('TelemetryMainImpl', () => {
+
+    let level: TelemetryLevel;
+    let pushed: TelemetryLevel[];
+    let levelChanged: Emitter<TelemetryLevel>;
+    let container: Container;
+    let rpc: RPCProtocol;
+
+    beforeEach(() => {
+        level = 'off';
+        pushed = [];
+        levelChanged = new Emitter<TelemetryLevel>();
+        container = new Container();
+        container.bind(TelemetryConsentProvider).toConstantValue(<TelemetryConsentProvider>{
+            get level(): TelemetryLevel { return level; },
+            onDidChangeTelemetryLevel: levelChanged.event,
+            ready: Promise.resolve()
+        });
+        rpc = {
+            getProxy<T>(_proxyId: unknown): T {
+                return {
+                    $onDidChangeTelemetryLevel: (next: TelemetryLevel) => { pushed.push(next); }
+                } as unknown as T;
+            },
+            set: <T, R extends T>(_identifier: unknown, instance: R) => instance,
+            dispose: () => { }
+        } as RPCProtocol;
+    });
+
+    it('does not push a level on construction, the initial level is seeded through $init', () => {
+        new TelemetryMainImpl(rpc, container);
+
+        expect(pushed).to.be.empty;
+    });
+
+    it('pushes every level change to the plugin host', () => {
+        new TelemetryMainImpl(rpc, container);
+
+        levelChanged.fire('all');
+        levelChanged.fire('error');
+
+        expect(pushed).to.deep.equal(['all', 'error']);
+    });
+
+    it('stops pushing once disposed', () => {
+        const telemetryMain = new TelemetryMainImpl(rpc, container);
+
+        telemetryMain.dispose();
+        levelChanged.fire('all');
+
+        expect(pushed).to.be.empty;
+    });
+});

package/src/main/browser/telemetry-main.ts

@@ -0,0 +1,46 @@
+// *****************************************************************************
+// Copyright (C) 2026 JuliaHub, Inc. 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 { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
+import { interfaces } from '@theia/core/shared/inversify';
+import { TelemetryConsentProvider } from '@theia/telemetry/lib/common/telemetry-consent-provider';
+import { MAIN_RPC_CONTEXT, TelemetryExt, TelemetryMain } from '../../common/plugin-api-rpc';
+import { RPCProtocol } from '../../common/rpc-protocol';
+
+/**
+ * Forwards the user's telemetry consent to the plugin host. The initial level is seeded through
+ * `PluginManagerInitializeParams` so that it is in place before any plugin activates.
+ *
+ * `TelemetryMain` declares no `$` methods; the instance is registered with the RPC protocol so that the consent
+ * subscription is disposed along with the channel.
+ *
+ * @experimental
+ */
+export class TelemetryMainImpl implements TelemetryMain, Disposable {
+
+    protected readonly proxy: TelemetryExt;
+    protected readonly toDispose = new DisposableCollection();
+
+    constructor(rpc: RPCProtocol, container: interfaces.Container) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.TELEMETRY_EXT);
+        const consentProvider = container.get<TelemetryConsentProvider>(TelemetryConsentProvider);
+        this.toDispose.push(consentProvider.onDidChangeTelemetryLevel(level => this.proxy.$onDidChangeTelemetryLevel(level)));
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+}

package/src/main/browser/webview/webview-context-keys.ts

@@ -14,14 +14,18 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { ApplicationShell, FocusTracker, Widget } from '@theia/core/lib/browser';
+import { ApplicationShell, FocusTracker, Widget, WidgetContextKeyContribution } from '@theia/core/lib/browser';
 import { ContextKey, ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { CustomEditorWidget } from '../custom-editors/custom-editor-widget';
+import { CodeEditorWidgetUtil } from '../menus/vscode-theia-menu-mappings';
 import { WebviewWidget } from './webview';
 
+const ACTIVE_WEBVIEW_PANEL_ID = 'activeWebviewPanelId';
+const ACTIVE_CUSTOM_EDITOR_ID = 'activeCustomEditorId';
+
 @injectable()
-export class WebviewContextKeys {
+export class WebviewContextKeys implements WidgetContextKeyContribution {
 
     /**
      * Context key representing the `viewType` of the active `WebviewWidget`, if any.
@@ -41,11 +45,23 @@ export class WebviewContextKeys {
 
     @postConstruct()
     protected init(): void {
-        this.activeWebviewPanelId = this.contextKeyService.createKey('activeWebviewPanelId', '');
-        this.activeCustomEditorId = this.contextKeyService.createKey('activeCustomEditorId', '');
+        this.activeWebviewPanelId = this.contextKeyService.createKey(ACTIVE_WEBVIEW_PANEL_ID, '');
+        this.activeCustomEditorId = this.contextKeyService.createKey(ACTIVE_CUSTOM_EDITOR_ID, '');
         this.applicationShell.onDidChangeCurrentWidget(this.handleDidChangeCurrentWidget, this);
     }
 
+    getContextKeyValues(widget: Widget): Iterable<[string, unknown]> | undefined {
+        // A view toolbar item may key on the *active* editor, so only the editor-like widgets these keys can
+        // describe get an answer; everything else keeps the ambient value.
+        if (!CodeEditorWidgetUtil.is(widget)) {
+            return undefined;
+        }
+        return [
+            [ACTIVE_CUSTOM_EDITOR_ID, widget instanceof CustomEditorWidget ? widget.viewType : ''],
+            [ACTIVE_WEBVIEW_PANEL_ID, widget instanceof WebviewWidget ? widget.viewType : '']
+        ];
+    }
+
     protected handleDidChangeCurrentWidget(change: FocusTracker.IChangedArgs<Widget>): void {
         const { newValue } = change;
         if (newValue instanceof CustomEditorWidget) {

package/src/plugin/plugin-context.ts

@@ -325,7 +325,8 @@ export function createAPIFactory(
     messageRegistryExt: MessageRegistryExt,
     clipboard: ClipboardExt,
     webviewExt: WebviewsExtImpl,
-    localizationExt: LocalizationExtImpl
+    localizationExt: LocalizationExtImpl,
+    telemetryExt: TelemetryExtImpl
 ): PluginAPIFactory {
 
     const authenticationExt = rpc.set(MAIN_RPC_CONTEXT.AUTHENTICATION_EXT, new AuthenticationExtImpl(rpc));
@@ -359,12 +360,12 @@ export function createAPIFactory(
     const tabsExt = rpc.set(MAIN_RPC_CONTEXT.TABS_EXT, new TabsExtImpl(rpc));
     const customEditorExt = rpc.set(MAIN_RPC_CONTEXT.CUSTOM_EDITORS_EXT, new CustomEditorsExtImpl(rpc, documents, webviewExt));
     const webviewViewsExt = rpc.set(MAIN_RPC_CONTEXT.WEBVIEW_VIEWS_EXT, new WebviewViewsExtImpl(rpc, webviewExt));
-    const telemetryExt = rpc.set(MAIN_RPC_CONTEXT.TELEMETRY_EXT, new TelemetryExtImpl());
     const testingExt = rpc.set(MAIN_RPC_CONTEXT.TESTING_EXT, new TestingExtImpl(rpc, commandRegistry));
     const uriExt = rpc.set(MAIN_RPC_CONTEXT.URI_EXT, new UriExtImpl(rpc));
     const lmExt = rpc.set(MAIN_RPC_CONTEXT.MCP_SERVER_DEFINITION_REGISTRY_EXT, new LmExtImpl(rpc));
     const lmToolExt = rpc.set(MAIN_RPC_CONTEXT.LM_TOOLS_EXT, new LanguageModelToolsExtImpl(rpc));
     rpc.set(MAIN_RPC_CONTEXT.DEBUG_EXT, debugExt);
+    rpc.set(MAIN_RPC_CONTEXT.TELEMETRY_EXT, telemetryExt);
 
     const commandLogger = new PluginLogger(rpc, 'commands-plugin');
 

package/src/plugin/plugin-manager.ts

@@ -37,6 +37,7 @@ import * as theia from '@theia/plugin';
 import * as types from './types-impl';
 import { join } from './path';
 import { EnvExtImpl } from './env';
+import { TelemetryExtImpl } from './telemetry-ext';
 import { PreferenceRegistryExtImpl } from './preference-registry';
 import { InternalStorageExt, Memento, GlobalState } from './plugin-storage';
 import { ExtPluginApi } from '../common/plugin-ext-api-contribution';
@@ -474,6 +475,9 @@ export class PluginManagerExtImpl extends AbstractPluginManagerExtImpl<PluginMan
     @inject(WebviewsExtImpl)
     protected readonly webview: WebviewsExtImpl;
 
+    @inject(TelemetryExtImpl)
+    protected readonly telemetryExt: TelemetryExtImpl;
+
     private supportedActivationEvents: Set<string>;
 
     async $init(params: PluginManagerInitializeParams): Promise<void> {
@@ -489,6 +493,8 @@ export class PluginManagerExtImpl extends AbstractPluginManagerExtImpl<PluginMan
         this.envExt.setAppUriScheme(params.env.appUriScheme);
 
         this.preferencesManager.init(params.preferences);
+        // must be in place before activation: plugins create their telemetry loggers during `activate()`
+        this.telemetryExt.setLevel(params.telemetryLevel ?? 'off');
 
         if (params.extApi) {
             this.host.initExtApi(params.extApi);

package/src/plugin/telemetry-ext.spec.ts

@@ -15,47 +15,188 @@
 // *****************************************************************************
 
 import * as chai from 'chai';
+import { TelemetryLevel } from '@theia/telemetry/lib/common/telemetry-types';
 import { TelemetryExtImpl } from './telemetry-ext';
 
 const expect = chai.expect;
 
-describe('TelemetryLogger', () => {
+describe('TelemetryExtImpl', () => {
     const sender = {
         sendEventData: () => { },
         sendErrorData: () => { }
     };
 
-    it('reflects the current telemetry enabled state', () => {
+    interface Expectation {
+        isTelemetryEnabled: boolean;
+        isUsageEnabled: boolean;
+        isErrorsEnabled: boolean;
+    }
+
+    const expectations: Record<TelemetryLevel, Expectation> = {
+        off: { isTelemetryEnabled: false, isUsageEnabled: false, isErrorsEnabled: false },
+        crash: { isTelemetryEnabled: false, isUsageEnabled: false, isErrorsEnabled: false },
+        error: { isTelemetryEnabled: false, isUsageEnabled: false, isErrorsEnabled: true },
+        all: { isTelemetryEnabled: true, isUsageEnabled: true, isErrorsEnabled: true }
+    };
+
+    for (const level of ['off', 'crash', 'error', 'all'] as const) {
+        const expected = expectations[level];
+
+        it(`derives the enablement states from telemetry level '${level}'`, () => {
+            const telemetry = new TelemetryExtImpl();
+            telemetry.$onDidChangeTelemetryLevel(level);
+            const logger = telemetry.createTelemetryLogger(sender);
+
+            expect(telemetry.level).to.equal(level);
+            expect(telemetry.isTelemetryEnabled).to.equal(expected.isTelemetryEnabled);
+            expect(logger.isUsageEnabled).to.equal(expected.isUsageEnabled);
+            expect(logger.isErrorsEnabled).to.equal(expected.isErrorsEnabled);
+        });
+
+        it(`applies telemetry level '${level}' to loggers created before the level arrived`, () => {
+            const telemetry = new TelemetryExtImpl();
+            const logger = telemetry.createTelemetryLogger(sender);
+            telemetry.$onDidChangeTelemetryLevel(level);
+
+            expect(logger.isUsageEnabled).to.equal(expected.isUsageEnabled);
+            expect(logger.isErrorsEnabled).to.equal(expected.isErrorsEnabled);
+        });
+    }
+
+    it('only fires onDidChangeTelemetryEnabled when the boolean it reports changes', () => {
+        const telemetry = new TelemetryExtImpl();
+        const fired: boolean[] = [];
+        telemetry.onDidChangeTelemetryEnabled(enabled => fired.push(enabled));
+
+        telemetry.$onDidChangeTelemetryLevel('crash');
+        telemetry.$onDidChangeTelemetryLevel('error');
+        telemetry.$onDidChangeTelemetryLevel('all');
+        telemetry.$onDidChangeTelemetryLevel('off');
+
+        expect(fired).to.deep.equal([true, false]);
+    });
+
+    it('fires onDidChangeEnableStates once per transition that changes an enablement state', () => {
         const telemetry = new TelemetryExtImpl();
         const logger = telemetry.createTelemetryLogger(sender);
+        let changes = 0;
+        logger.onDidChangeEnableStates(() => changes++);
 
-        expect(logger.telemetryEnabled).to.equal(false);
-        expect(logger.isUsageEnabled).to.equal(false);
-        expect(logger.isErrorsEnabled).to.equal(false);
+        telemetry.$onDidChangeTelemetryLevel('crash'); // off -> crash: both stay false
+        expect(changes).to.equal(0);
 
-        telemetry.isTelemetryEnabled = true;
+        telemetry.$onDidChangeTelemetryLevel('error'); // errors become enabled
+        expect(changes).to.equal(1);
 
-        expect(logger.telemetryEnabled).to.equal(true);
-        expect(logger.isUsageEnabled).to.equal(true);
-        expect(logger.isErrorsEnabled).to.equal(true);
+        telemetry.$onDidChangeTelemetryLevel('all'); // usage becomes enabled
+        expect(changes).to.equal(2);
 
-        telemetry.isTelemetryEnabled = false;
+        telemetry.$onDidChangeTelemetryLevel('off');
+        expect(changes).to.equal(3);
+    });
 
-        expect(logger.telemetryEnabled).to.equal(false);
+    it('stops following the level once the logger is disposed', () => {
+        const telemetry = new TelemetryExtImpl();
+        const logger = telemetry.createTelemetryLogger(sender);
+        let changes = 0;
+        logger.onDidChangeEnableStates(() => changes++);
+
+        logger.dispose();
+        telemetry.$onDidChangeTelemetryLevel('all');
         expect(logger.isUsageEnabled).to.equal(false);
-        expect(logger.isErrorsEnabled).to.equal(false);
+
+        logger.isUsageEnabled = true;
+        expect(changes).to.equal(0);
+    });
+
+    it('logs rather than propagates a sender that fails to flush on disposal', async () => {
+        const telemetry = new TelemetryExtImpl();
+        const logged: unknown[] = [];
+        const consoleError = console.error;
+        console.error = (...args: unknown[]) => { logged.push(args); };
+        try {
+            telemetry.createTelemetryLogger({ ...sender, flush: () => { throw new Error('boom'); } }).dispose();
+            telemetry.createTelemetryLogger({ ...sender, flush: () => Promise.reject(new Error('boom')) }).dispose();
+            await new Promise(resolve => setTimeout(resolve, 0));
+        } finally {
+            console.error = consoleError;
+        }
+
+        expect(logged).to.have.lengthOf(2);
     });
 
-    it('emits enable-state changes when telemetry is toggled', () => {
+    it('ignores a repeated telemetry level', () => {
         const telemetry = new TelemetryExtImpl();
         const logger = telemetry.createTelemetryLogger(sender);
         let changes = 0;
-
         logger.onDidChangeEnableStates(() => changes++);
 
-        telemetry.isTelemetryEnabled = true;
-        telemetry.isTelemetryEnabled = false;
+        telemetry.$onDidChangeTelemetryLevel('all');
+        telemetry.$onDidChangeTelemetryLevel('all');
 
-        expect(changes).to.equal(2);
+        expect(changes).to.equal(1);
+    });
+});
+
+describe('TelemetryLogger', () => {
+
+    interface RecordingSender {
+        events: string[];
+        errors: Error[];
+        sendEventData(eventName: string): void;
+        sendErrorData(error: Error): void;
+    }
+
+    function createSender(): RecordingSender {
+        const events: string[] = [];
+        const errors: Error[] = [];
+        return {
+            events,
+            errors,
+            sendEventData: (eventName: string) => events.push(eventName),
+            sendErrorData: (error: Error) => errors.push(error)
+        };
+    }
+
+    it('delivers errors but suppresses usage at telemetry level \'error\'', () => {
+        const telemetry = new TelemetryExtImpl();
+        telemetry.$onDidChangeTelemetryLevel('error');
+        const sender = createSender();
+        const logger = telemetry.createTelemetryLogger(sender);
+
+        logger.logUsage('usage-event');
+        logger.logError('error-event');
+        logger.logError(new Error('boom'));
+
+        expect(sender.events).to.deep.equal(['error-event']);
+        expect(sender.errors).to.have.lengthOf(1);
+    });
+
+    it('suppresses usage that a plugin re-enables while the telemetry level forbids it', () => {
+        const telemetry = new TelemetryExtImpl();
+        telemetry.$onDidChangeTelemetryLevel('off');
+        const sender = createSender();
+        const logger = telemetry.createTelemetryLogger(sender);
+
+        logger.isUsageEnabled = true;
+        logger.isErrorsEnabled = true;
+        logger.logUsage('usage-event');
+        logger.logError('error-event');
+
+        expect(sender.events).to.be.empty;
+    });
+
+    it('refuses to let a plugin assign the telemetry level of its logger', () => {
+        const telemetry = new TelemetryExtImpl();
+        telemetry.$onDidChangeTelemetryLevel('off');
+        const sender = createSender();
+        const logger = telemetry.createTelemetryLogger(sender);
+
+        expect(Reflect.set(logger, 'level', 'all')).to.be.false;
+        logger.logUsage('usage-event');
+
+        expect(logger.level).to.equal('off');
+        expect(logger.isUsageEnabled).to.be.false;
+        expect(sender.events).to.be.empty;
     });
 });