@codingame/monaco-vscode-telemetry-service-override 13.1.0

package/index.d.ts

@@ -0,0 +1,3 @@
+import { type IEditorOverrideServices } from "@codingame/monaco-vscode-api/vscode/vs/editor/standalone/browser/standaloneServices";
+export type { ITelemetryData, TelemetryLevel } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry";
+export default function getServiceOverride(): IEditorOverrideServices;

package/index.js

@@ -0,0 +1,15 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/editor/standalone/browser/standaloneServices';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import '@codingame/monaco-vscode-api/services';
+import { TelemetryService } from './vscode/src/vs/workbench/services/telemetry/browser/telemetryService.js';
+import './vscode/src/vs/workbench/contrib/telemetry/browser/telemetry.contribution.js';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+
+function getServiceOverride() {
+    return {
+        [ITelemetryService.toString()]: new SyncDescriptor(TelemetryService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@codingame/monaco-vscode-telemetry-service-override",
+  "version": "13.1.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - telemetry service-override",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-411e0589-fa79-504b-b32c-80a88847b23a-common": "13.1.0",
+    "@codingame/monaco-vscode-7443a901-21f6-577a-9674-42893b997ee0-common": "13.1.0",
+    "@codingame/monaco-vscode-972e8507-3a64-566d-8bc0-b78993998562-common": "13.1.0",
+    "@codingame/monaco-vscode-api": "13.1.0",
+    "@codingame/monaco-vscode-e7080bda-ce3e-5243-9a35-98cd9634dbda-common": "13.1.0",
+    "@microsoft/1ds-core-js": "3.2.18",
+    "@microsoft/1ds-post-js": "3.2.18"
+  },
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./vscode/*": {
+      "default": "./vscode/src/*.js",
+      "types": "./vscode/src/*.d.ts"
+    },
+    "./*": {
+      "default": "./*.js",
+      "types": "./*.d.ts"
+    }
+  }
+}

package/vscode/src/vs/platform/telemetry/browser/1dsAppender.d.ts

@@ -0,0 +1,6 @@
+import { AbstractOneDataSystemAppender, IAppInsightsCore } from "../common/1dsAppender.js";
+export declare class OneDataSystemWebAppender extends AbstractOneDataSystemAppender {
+    constructor(isInternalTelemetry: boolean, eventPrefix: string, defaultData: {
+        [key: string]: any;
+    } | null, iKeyOrClientFactory: string | (() => IAppInsightsCore));
+}

package/vscode/src/vs/platform/telemetry/browser/1dsAppender.js

@@ -0,0 +1,13 @@
+
+import { AbstractOneDataSystemAppender } from '../common/1dsAppender.js';
+
+class OneDataSystemWebAppender extends AbstractOneDataSystemAppender {
+    constructor(isInternalTelemetry, eventPrefix, defaultData, iKeyOrClientFactory) {
+        super(isInternalTelemetry, eventPrefix, defaultData, iKeyOrClientFactory);
+        fetch(this.endPointHealthUrl, { method: 'GET' }).catch(err => {
+            this._aiCoreOrKey = undefined;
+        });
+    }
+}
+
+export { OneDataSystemWebAppender };

package/vscode/src/vs/platform/telemetry/browser/errorTelemetry.d.ts

@@ -0,0 +1,5 @@
+import BaseErrorTelemetry from "../common/errorTelemetry.js";
+export default class ErrorTelemetry extends BaseErrorTelemetry {
+    protected installErrorListeners(): void;
+    private _onUncaughtError;
+}

package/vscode/src/vs/platform/telemetry/browser/errorTelemetry.js

@@ -0,0 +1,51 @@
+
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import BaseErrorTelemetry from '../common/errorTelemetry.js';
+
+class ErrorTelemetry extends BaseErrorTelemetry {
+    installErrorListeners() {
+        let oldOnError;
+        const that = this;
+        if (typeof mainWindow.onerror === 'function') {
+            oldOnError = mainWindow.onerror;
+        }
+        mainWindow.onerror = function (message, filename, line, column, error) {
+            that._onUncaughtError(message, filename, line, column, error);
+            oldOnError?.apply(this, [message, filename, line, column, error]);
+        };
+        this._disposables.add(toDisposable(() => {
+            if (oldOnError) {
+                mainWindow.onerror = oldOnError;
+            }
+        }));
+    }
+    _onUncaughtError(msg, file, line, column, err) {
+        const data = {
+            callstack: msg,
+            msg,
+            file,
+            line,
+            column
+        };
+        if (err) {
+            if (ErrorNoTelemetry.isErrorNoTelemetry(err)) {
+                return;
+            }
+            const { name, message, stack } = err;
+            data.uncaught_error_name = name;
+            if (message) {
+                data.uncaught_error_msg = message;
+            }
+            if (stack) {
+                data.callstack = Array.isArray(err.stack)
+                    ? err.stack = err.stack.join('\n')
+                    : err.stack;
+            }
+        }
+        this._enqueue(data);
+    }
+}
+
+export { ErrorTelemetry as default };

package/vscode/src/vs/platform/telemetry/common/1dsAppender.d.ts

@@ -0,0 +1,24 @@
+import type { IExtendedTelemetryItem, ITelemetryItem, ITelemetryUnloadState } from "@microsoft/1ds-core-js";
+import type { IXHROverride } from "@microsoft/1ds-post-js";
+import { ITelemetryAppender } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils";
+export interface IAppInsightsCore {
+    pluginVersionString: string;
+    track(item: ITelemetryItem | IExtendedTelemetryItem): void;
+    unload(isAsync: boolean, unloadComplete: (unloadState: ITelemetryUnloadState) => void): void;
+}
+export declare abstract class AbstractOneDataSystemAppender implements ITelemetryAppender {
+    private readonly _isInternalTelemetry;
+    private _eventPrefix;
+    private _defaultData;
+    private _xhrOverride?;
+    protected _aiCoreOrKey: IAppInsightsCore | string | undefined;
+    private _asyncAiCore;
+    protected readonly endPointUrl = "https://mobile.events.data.microsoft.com/OneCollector/1.0";
+    protected readonly endPointHealthUrl = "https://mobile.events.data.microsoft.com/ping";
+    constructor(_isInternalTelemetry: boolean, _eventPrefix: string, _defaultData: {
+        [key: string]: any;
+    } | null, iKeyOrClientFactory: string | (() => IAppInsightsCore), _xhrOverride?: IXHROverride | undefined);
+    private _withAIClient;
+    log(eventName: string, data?: any): void;
+    flush(): Promise<void>;
+}

package/vscode/src/vs/platform/telemetry/common/1dsAppender.js

@@ -0,0 +1,117 @@
+
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { mixin } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { validateTelemetryData } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
+
+const endpointUrl = 'https://mobile.events.data.microsoft.com/OneCollector/1.0';
+const endpointHealthUrl = 'https://mobile.events.data.microsoft.com/ping';
+async function getClient(instrumentationKey, addInternalFlag, xhrOverride) {
+    const oneDs = await import('@microsoft/1ds-core-js').then(module => module.default ?? module);
+    const postPlugin = await import('@microsoft/1ds-post-js').then(module => module.default ?? module);
+    const appInsightsCore = new oneDs.AppInsightsCore();
+    const collectorChannelPlugin = new postPlugin.PostChannel();
+    const coreConfig = {
+        instrumentationKey,
+        endpointUrl,
+        loggingLevelTelemetry: 0,
+        loggingLevelConsole: 0,
+        disableCookiesUsage: true,
+        disableDbgExt: true,
+        disableInstrumentationKeyValidation: true,
+        channels: [[
+                collectorChannelPlugin
+            ]]
+    };
+    if (xhrOverride) {
+        coreConfig.extensionConfig = {};
+        const channelConfig = {
+            alwaysUseXhrOverride: true,
+            ignoreMc1Ms0CookieProcessing: true,
+            httpXHROverride: xhrOverride
+        };
+        coreConfig.extensionConfig[collectorChannelPlugin.identifier] = channelConfig;
+    }
+    appInsightsCore.initialize(coreConfig, []);
+    appInsightsCore.addTelemetryInitializer((envelope) => {
+        envelope['ext'] = envelope['ext'] ?? {};
+        envelope['ext']['web'] = envelope['ext']['web'] ?? {};
+        envelope['ext']['web']['consentDetails'] = '{"GPC_DataSharingOptIn":false}';
+        if (addInternalFlag) {
+            envelope['ext']['utc'] = envelope['ext']['utc'] ?? {};
+            envelope['ext']['utc']['flags'] = 0x0000811ECD;
+        }
+    });
+    return appInsightsCore;
+}
+class AbstractOneDataSystemAppender {
+    constructor(_isInternalTelemetry, _eventPrefix, _defaultData, iKeyOrClientFactory,
+    _xhrOverride) {
+        this._isInternalTelemetry = _isInternalTelemetry;
+        this._eventPrefix = _eventPrefix;
+        this._defaultData = _defaultData;
+        this._xhrOverride = _xhrOverride;
+        this.endPointUrl = endpointUrl;
+        this.endPointHealthUrl = endpointHealthUrl;
+        if (!this._defaultData) {
+            this._defaultData = {};
+        }
+        if (typeof iKeyOrClientFactory === 'function') {
+            this._aiCoreOrKey = iKeyOrClientFactory();
+        }
+        else {
+            this._aiCoreOrKey = iKeyOrClientFactory;
+        }
+        this._asyncAiCore = null;
+    }
+    _withAIClient(callback) {
+        if (!this._aiCoreOrKey) {
+            return;
+        }
+        if (typeof this._aiCoreOrKey !== 'string') {
+            callback(this._aiCoreOrKey);
+            return;
+        }
+        if (!this._asyncAiCore) {
+            this._asyncAiCore = getClient(this._aiCoreOrKey, this._isInternalTelemetry, this._xhrOverride);
+        }
+        this._asyncAiCore.then((aiClient) => {
+            callback(aiClient);
+        }, (err) => {
+            onUnexpectedError(err);
+            console.error(err);
+        });
+    }
+    log(eventName, data) {
+        if (!this._aiCoreOrKey) {
+            return;
+        }
+        data = mixin(data, this._defaultData);
+        data = validateTelemetryData(data);
+        const name = this._eventPrefix + '/' + eventName;
+        try {
+            this._withAIClient((aiClient) => {
+                aiClient.pluginVersionString = data?.properties.version ?? 'Unknown';
+                aiClient.track({
+                    name,
+                    baseData: { name, properties: data?.properties, measurements: data?.measurements }
+                });
+            });
+        }
+        catch { }
+    }
+    flush() {
+        if (this._aiCoreOrKey) {
+            return ( new Promise(resolve => {
+                this._withAIClient((aiClient) => {
+                    aiClient.unload(true, () => {
+                        this._aiCoreOrKey = undefined;
+                        resolve(undefined);
+                    });
+                });
+            }));
+        }
+        return Promise.resolve(undefined);
+    }
+}
+
+export { AbstractOneDataSystemAppender };

package/vscode/src/vs/platform/telemetry/common/errorTelemetry.d.ts

@@ -0,0 +1,29 @@
+import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+export interface ErrorEvent {
+    callstack: string;
+    msg?: string;
+    file?: string;
+    line?: number;
+    column?: number;
+    uncaught_error_name?: string;
+    uncaught_error_msg?: string;
+    count?: number;
+}
+export declare namespace ErrorEvent {
+    function compare(a: ErrorEvent, b: ErrorEvent): 0 | 1 | -1;
+}
+export default abstract class BaseErrorTelemetry {
+    static ERROR_FLUSH_TIMEOUT: number;
+    private _telemetryService;
+    private _flushDelay;
+    private _flushHandle;
+    private _buffer;
+    protected readonly _disposables: DisposableStore;
+    constructor(telemetryService: ITelemetryService, flushDelay?: number);
+    dispose(): void;
+    protected installErrorListeners(): void;
+    private _onErrorEvent;
+    protected _enqueue(e: ErrorEvent): void;
+    private _flushBuffer;
+}

package/vscode/src/vs/platform/telemetry/common/errorTelemetry.js

@@ -0,0 +1,84 @@
+
+import { binarySearch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { errorHandler, ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { safeStringify } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { FileOperationError } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+
+var ErrorEvent;
+(function (ErrorEvent) {
+    function compare(a, b) {
+        if (a.callstack < b.callstack) {
+            return -1;
+        }
+        else if (a.callstack > b.callstack) {
+            return 1;
+        }
+        return 0;
+    }
+    ErrorEvent.compare = compare;
+})(ErrorEvent || (ErrorEvent = {}));
+class BaseErrorTelemetry {
+    static { this.ERROR_FLUSH_TIMEOUT = 5 * 1000; }
+    constructor(telemetryService, flushDelay = BaseErrorTelemetry.ERROR_FLUSH_TIMEOUT) {
+        this._flushHandle = -1;
+        this._buffer = [];
+        this._disposables = ( new DisposableStore());
+        this._telemetryService = telemetryService;
+        this._flushDelay = flushDelay;
+        const unbind = errorHandler.addListener((err) => this._onErrorEvent(err));
+        this._disposables.add(toDisposable(unbind));
+        this.installErrorListeners();
+    }
+    dispose() {
+        clearTimeout(this._flushHandle);
+        this._flushBuffer();
+        this._disposables.dispose();
+    }
+    installErrorListeners() {
+    }
+    _onErrorEvent(err) {
+        if (!err || err.code) {
+            return;
+        }
+        if (err.detail && err.detail.stack) {
+            err = err.detail;
+        }
+        if (ErrorNoTelemetry.isErrorNoTelemetry(err) || err instanceof FileOperationError || (typeof err?.message === 'string' && err.message.includes('Unable to read file'))) {
+            return;
+        }
+        const callstack = Array.isArray(err.stack) ? err.stack.join('\n') : err.stack;
+        const msg = err.message ? err.message : safeStringify(err);
+        if (!callstack) {
+            return;
+        }
+        this._enqueue({ msg, callstack });
+    }
+    _enqueue(e) {
+        const idx = binarySearch(this._buffer, e, ErrorEvent.compare);
+        if (idx < 0) {
+            e.count = 1;
+            this._buffer.splice(~idx, 0, e);
+        }
+        else {
+            if (!this._buffer[idx].count) {
+                this._buffer[idx].count = 0;
+            }
+            this._buffer[idx].count += 1;
+        }
+        if (this._flushHandle === -1) {
+            this._flushHandle = setTimeout(() => {
+                this._flushBuffer();
+                this._flushHandle = -1;
+            }, this._flushDelay);
+        }
+    }
+    _flushBuffer() {
+        for (const error of this._buffer) {
+            this._telemetryService.publicLogError2('UnhandledError', error);
+        }
+        this._buffer.length = 0;
+    }
+}
+
+export { ErrorEvent, BaseErrorTelemetry as default };

package/vscode/src/vs/platform/telemetry/common/telemetryLogAppender.d.ts

@@ -0,0 +1,13 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
+import { ILoggerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { ITelemetryAppender } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils";
+export declare class TelemetryLogAppender extends Disposable implements ITelemetryAppender {
+    private readonly prefix;
+    private readonly logger;
+    constructor(logService: ILogService, loggerService: ILoggerService, environmentService: IEnvironmentService, productService: IProductService, prefix?: string);
+    flush(): Promise<void>;
+    log(eventName: string, data: any): void;
+}

package/vscode/src/vs/platform/telemetry/common/telemetryLogAppender.js

@@ -0,0 +1,43 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
+import { LogLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
+import { ILogService, ILoggerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { telemetryLogId, isLoggingOnly, supportsTelemetry, validateTelemetryData } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
+
+let TelemetryLogAppender = class TelemetryLogAppender extends Disposable {
+    constructor(logService, loggerService, environmentService, productService, prefix = '') {
+        super();
+        this.prefix = prefix;
+        const logger = loggerService.getLogger(telemetryLogId);
+        if (logger) {
+            this.logger = this._register(logger);
+        }
+        else {
+            const justLoggingAndNotSending = isLoggingOnly(productService, environmentService);
+            const logSuffix = justLoggingAndNotSending ? ' (Not Sent)' : '';
+            const isVisible = () => supportsTelemetry(productService, environmentService) && logService.getLevel() === LogLevel.Trace;
+            this.logger = this._register(loggerService.createLogger(telemetryLogId, { name: ( localize(1872, "Telemetry{0}", logSuffix)), hidden: !isVisible() }));
+            this._register(logService.onDidChangeLogLevel(() => loggerService.setVisibility(telemetryLogId, isVisible())));
+            this.logger.info('Below are logs for every telemetry event sent from VS Code once the log level is set to trace.');
+            this.logger.info('===========================================================');
+        }
+    }
+    flush() {
+        return Promise.resolve();
+    }
+    log(eventName, data) {
+        this.logger.trace(`${this.prefix}telemetry/${eventName}`, validateTelemetryData(data));
+    }
+};
+TelemetryLogAppender = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, ILoggerService)),
+    ( __param(2, IEnvironmentService)),
+    ( __param(3, IProductService))
+], TelemetryLogAppender));
+
+export { TelemetryLogAppender };

package/vscode/src/vs/platform/telemetry/common/telemetryService.d.ts

@@ -0,0 +1,44 @@
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/gdprTypings";
+import { ITelemetryData, TelemetryLevel, ICommonProperties } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { ITelemetryAppender } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils";
+export interface ITelemetryServiceConfig {
+    appenders: ITelemetryAppender[];
+    sendErrorTelemetry?: boolean;
+    commonProperties?: ICommonProperties;
+    piiPaths?: string[];
+}
+export declare class TelemetryService implements ITelemetryService {
+    private _configurationService;
+    private _productService;
+    static readonly IDLE_START_EVENT_NAME = "UserIdleStart";
+    static readonly IDLE_STOP_EVENT_NAME = "UserIdleStop";
+    readonly _serviceBrand: undefined;
+    readonly sessionId: string;
+    readonly machineId: string;
+    readonly sqmId: string;
+    readonly devDeviceId: string;
+    readonly firstSessionDate: string;
+    readonly msftInternal: boolean | undefined;
+    private _appenders;
+    private _commonProperties;
+    private _experimentProperties;
+    private _piiPaths;
+    private _telemetryLevel;
+    private _sendErrorTelemetry;
+    private readonly _disposables;
+    private _cleanupPatterns;
+    constructor(config: ITelemetryServiceConfig, _configurationService: IConfigurationService, _productService: IProductService);
+    setExperimentProperty(name: string, value: string): void;
+    private _updateTelemetryLevel;
+    get sendErrorTelemetry(): boolean;
+    get telemetryLevel(): TelemetryLevel;
+    dispose(): void;
+    private _log;
+    publicLog(eventName: string, data?: ITelemetryData): void;
+    publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
+    publicLogError(errorEventName: string, data?: ITelemetryData): void;
+    publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
+}

package/vscode/src/vs/platform/telemetry/common/telemetryService.js

@@ -0,0 +1,212 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { mixin } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { Extensions, ConfigurationScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { TelemetryLevel, TELEMETRY_SETTING_ID, TELEMETRY_OLD_SETTING_ID, TELEMETRY_CRASH_REPORTER_SETTING_ID, TELEMETRY_SECTION_ID, TelemetryConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
+import { getTelemetryLevel, cleanData } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
+
+let TelemetryService = class TelemetryService {
+    static { this.IDLE_START_EVENT_NAME = 'UserIdleStart'; }
+    static { this.IDLE_STOP_EVENT_NAME = 'UserIdleStop'; }
+    constructor(config, _configurationService, _productService) {
+        this._configurationService = _configurationService;
+        this._productService = _productService;
+        this._experimentProperties = {};
+        this._disposables = ( new DisposableStore());
+        this._cleanupPatterns = [];
+        this._appenders = config.appenders;
+        this._commonProperties = config.commonProperties ?? Object.create(null);
+        this.sessionId = this._commonProperties['sessionID'];
+        this.machineId = this._commonProperties['common.machineId'];
+        this.sqmId = this._commonProperties['common.sqmId'];
+        this.devDeviceId = this._commonProperties['common.devDeviceId'];
+        this.firstSessionDate = this._commonProperties['common.firstSessionDate'];
+        this.msftInternal = this._commonProperties['common.msftInternal'];
+        this._piiPaths = config.piiPaths || [];
+        this._telemetryLevel = TelemetryLevel.USAGE;
+        this._sendErrorTelemetry = !!config.sendErrorTelemetry;
+        this._cleanupPatterns = [/(vscode-)?file:\/\/\/.*?\/resources\/app\//gi];
+        for (const piiPath of this._piiPaths) {
+            this._cleanupPatterns.push(( new RegExp(escapeRegExpCharacters(piiPath), 'gi')));
+            if (piiPath.indexOf('\\') >= 0) {
+                this._cleanupPatterns.push(( new RegExp(escapeRegExpCharacters(piiPath.replace(/\\/g, '/')), 'gi')));
+            }
+        }
+        this._updateTelemetryLevel();
+        this._disposables.add(this._configurationService.onDidChangeConfiguration(e => {
+            const affectsTelemetryConfig = e.affectsConfiguration(TELEMETRY_SETTING_ID)
+                || e.affectsConfiguration(TELEMETRY_OLD_SETTING_ID)
+                || e.affectsConfiguration(TELEMETRY_CRASH_REPORTER_SETTING_ID);
+            if (affectsTelemetryConfig) {
+                this._updateTelemetryLevel();
+            }
+        }));
+    }
+    setExperimentProperty(name, value) {
+        this._experimentProperties[name] = value;
+    }
+    _updateTelemetryLevel() {
+        let level = getTelemetryLevel(this._configurationService);
+        const collectableTelemetry = this._productService.enabledTelemetryLevels;
+        if (collectableTelemetry) {
+            this._sendErrorTelemetry = this.sendErrorTelemetry ? collectableTelemetry.error : false;
+            const maxCollectableTelemetryLevel = collectableTelemetry.usage ? TelemetryLevel.USAGE : collectableTelemetry.error ? TelemetryLevel.ERROR : TelemetryLevel.NONE;
+            level = Math.min(level, maxCollectableTelemetryLevel);
+        }
+        this._telemetryLevel = level;
+    }
+    get sendErrorTelemetry() {
+        return this._sendErrorTelemetry;
+    }
+    get telemetryLevel() {
+        return this._telemetryLevel;
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    _log(eventName, eventLevel, data) {
+        if (this._telemetryLevel < eventLevel) {
+            return;
+        }
+        data = mixin(data, this._experimentProperties);
+        data = cleanData(data, this._cleanupPatterns);
+        data = mixin(data, this._commonProperties);
+        this._appenders.forEach(a => a.log(eventName, data));
+    }
+    publicLog(eventName, data) {
+        this._log(eventName, TelemetryLevel.USAGE, data);
+    }
+    publicLog2(eventName, data) {
+        this.publicLog(eventName, data);
+    }
+    publicLogError(errorEventName, data) {
+        if (!this._sendErrorTelemetry) {
+            return;
+        }
+        this._log(errorEventName, TelemetryLevel.ERROR, data);
+    }
+    publicLogError2(eventName, data) {
+        this.publicLogError(eventName, data);
+    }
+};
+TelemetryService = ( __decorate([
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IProductService))
+], TelemetryService));
+function getTelemetryLevelSettingDescription() {
+    const telemetryText = ( localize(
+        1873,
+        "Controls {0} telemetry, first-party extension telemetry, and participating third-party extension telemetry. Some third party extensions might not respect this setting. Consult the specific extension's documentation to be sure. Telemetry helps us better understand how {0} is performing, where improvements need to be made, and how features are being used.",
+        product.nameLong
+    ));
+    const externalLinksStatement = !product.privacyStatementUrl ?
+        ( localize(
+        1874,
+        "Read more about the [data we collect]({0}).",
+        'https://aka.ms/vscode-telemetry'
+    )) :
+        ( localize(
+        1875,
+        "Read more about the [data we collect]({0}) and our [privacy statement]({1}).",
+        'https://aka.ms/vscode-telemetry',
+        product.privacyStatementUrl
+    ));
+    const restartString = !isWeb ? ( localize(
+        1876,
+        'A full restart of the application is necessary for crash reporting changes to take effect.'
+    )) : '';
+    const crashReportsHeader = ( localize(1877, "Crash Reports"));
+    const errorsHeader = ( localize(1878, "Error Telemetry"));
+    const usageHeader = ( localize(1879, "Usage Data"));
+    const telemetryTableDescription = ( localize(1880, "The following table outlines the data sent with each setting:"));
+    const telemetryTable = `
+|       | ${crashReportsHeader} | ${errorsHeader} | ${usageHeader} |
+|:------|:---------------------:|:---------------:|:--------------:|
+| all   |            ✓          |        ✓        |        ✓       |
+| error |            ✓          |        ✓        |        -       |
+| crash |            ✓          |        -        |        -       |
+| off   |            -          |        -        |        -       |
+`;
+    const deprecatedSettingNote = ( localize(
+        1881,
+        "****Note:*** If this setting is 'off', no telemetry will be sent regardless of other telemetry settings. If this setting is set to anything except 'off' and telemetry is disabled with deprecated settings, no telemetry will be sent.*"
+    ));
+    const telemetryDescription = `
+${telemetryText} ${externalLinksStatement} ${restartString}
+
+&nbsp;
+
+${telemetryTableDescription}
+${telemetryTable}
+
+&nbsp;
+
+${deprecatedSettingNote}
+`;
+    return telemetryDescription;
+}
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    'id': TELEMETRY_SECTION_ID,
+    'order': 1,
+    'type': 'object',
+    'title': ( localize(1882, "Telemetry")),
+    'properties': {
+        [TELEMETRY_SETTING_ID]: {
+            'type': 'string',
+            'enum': [TelemetryConfiguration.ON, TelemetryConfiguration.ERROR, TelemetryConfiguration.CRASH, TelemetryConfiguration.OFF],
+            'enumDescriptions': [
+                ( localize(1883, "Sends usage data, errors, and crash reports.")),
+                ( localize(1884, "Sends general error telemetry and crash reports.")),
+                ( localize(1885, "Sends OS level crash reports.")),
+                ( localize(1886, "Disables all product telemetry."))
+            ],
+            'markdownDescription': getTelemetryLevelSettingDescription(),
+            'default': TelemetryConfiguration.ON,
+            'restricted': true,
+            'scope': ConfigurationScope.APPLICATION,
+            'tags': ['usesOnlineServices', 'telemetry']
+        }
+    }
+});
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    'id': TELEMETRY_SECTION_ID,
+    'order': 110,
+    'type': 'object',
+    'title': ( localize(1882, "Telemetry")),
+    'properties': {
+        [TELEMETRY_OLD_SETTING_ID]: {
+            'type': 'boolean',
+            'markdownDescription': !product.privacyStatementUrl ?
+                ( localize(
+                1887,
+                "Enable diagnostic data to be collected. This helps us to better understand how {0} is performing and where improvements need to be made.",
+                product.nameLong
+            )) :
+                ( localize(
+                1888,
+                "Enable diagnostic data to be collected. This helps us to better understand how {0} is performing and where improvements need to be made. [Read more]({1}) about what we collect and our privacy statement.",
+                product.nameLong,
+                product.privacyStatementUrl
+            )),
+            'default': true,
+            'restricted': true,
+            'markdownDeprecationMessage': ( localize(
+                1889,
+                "If this setting is false, no telemetry will be sent regardless of the new setting's value. Deprecated in favor of the {0} setting.",
+                `\`#${TELEMETRY_SETTING_ID}#\``
+            )),
+            'scope': ConfigurationScope.APPLICATION,
+            'tags': ['usesOnlineServices', 'telemetry']
+        }
+    }
+});
+
+export { TelemetryService };

package/vscode/src/vs/workbench/contrib/telemetry/browser/telemetry.contribution.d.ts

@@ -0,0 +1,24 @@
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IWorkbenchThemeService } from "@codingame/monaco-vscode-7443a901-21f6-577a-9674-42893b997ee0-common/vscode/vs/workbench/services/themes/common/workbenchThemeService.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
+import { IPaneCompositePartService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/panecomposite/browser/panecomposite.service";
+import { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
+export declare class TelemetryContribution extends Disposable implements IWorkbenchContribution {
+    private readonly telemetryService;
+    private readonly contextService;
+    private readonly userDataProfileService;
+    private static ALLOWLIST_JSON;
+    private static ALLOWLIST_WORKSPACE_JSON;
+    constructor(telemetryService: ITelemetryService, contextService: IWorkspaceContextService, lifecycleService: ILifecycleService, editorService: IEditorService, keybindingsService: IKeybindingService, themeService: IWorkbenchThemeService, environmentService: IWorkbenchEnvironmentService, userDataProfileService: IUserDataProfileService, paneCompositeService: IPaneCompositePartService, textFileService: ITextFileService);
+    private onTextFileModelResolved;
+    private onTextFileModelSaved;
+    private getTypeIfSettings;
+    private getTelemetryData;
+}

package/vscode/src/vs/workbench/contrib/telemetry/browser/telemetry.contribution.js

@@ -0,0 +1,258 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { Extensions as Extensions$1 } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { WorkbenchState } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { IWorkbenchThemeService } from '@codingame/monaco-vscode-7443a901-21f6-577a-9674-42893b997ee0-common/vscode/vs/workbench/services/themes/common/workbenchThemeService.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { language } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import ErrorTelemetry from '../../../../platform/telemetry/browser/errorTelemetry.js';
+import { TelemetryTrustedValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { ConfigurationTarget, ConfigurationTargetToString } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { extname, isEqual, isEqualOrParent, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { getMimeTypes } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languagesAssociations';
+import { hash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { IPaneCompositePartService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/panecomposite/browser/panecomposite.service';
+import { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
+import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { isNumber, isBoolean, isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { LayoutSettings } from '@codingame/monaco-vscode-e7080bda-ce3e-5243-9a35-98cd9634dbda-common/vscode/vs/workbench/services/layout/browser/layoutService';
+import { AutoRestartConfigurationKey, AutoUpdateConfigurationKey } from '@codingame/monaco-vscode-972e8507-3a64-566d-8bc0-b78993998562-common/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { KEYWORD_ACTIVIATION_SETTING_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { IUserDataProfilesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+
+var TelemetryContribution_1;
+let TelemetryContribution = class TelemetryContribution extends Disposable {
+    static { TelemetryContribution_1 = this; }
+    static { this.ALLOWLIST_JSON = ['package.json', 'package-lock.json', 'tsconfig.json', 'jsconfig.json', 'bower.json', '.eslintrc.json', 'tslint.json', 'composer.json']; }
+    static { this.ALLOWLIST_WORKSPACE_JSON = ['settings.json', 'extensions.json', 'tasks.json', 'launch.json']; }
+    constructor(telemetryService, contextService, lifecycleService, editorService, keybindingsService, themeService, environmentService, userDataProfileService, paneCompositeService, textFileService) {
+        super();
+        this.telemetryService = telemetryService;
+        this.contextService = contextService;
+        this.userDataProfileService = userDataProfileService;
+        const { filesToOpenOrCreate, filesToDiff, filesToMerge } = environmentService;
+        const activeViewlet = paneCompositeService.getActivePaneComposite(ViewContainerLocation.Sidebar);
+        telemetryService.publicLog2('workspaceLoad', {
+            windowSize: { innerHeight: mainWindow.innerHeight, innerWidth: mainWindow.innerWidth, outerHeight: mainWindow.outerHeight, outerWidth: mainWindow.outerWidth },
+            emptyWorkbench: contextService.getWorkbenchState() === WorkbenchState.EMPTY,
+            'workbench.filesToOpenOrCreate': filesToOpenOrCreate && filesToOpenOrCreate.length || 0,
+            'workbench.filesToDiff': filesToDiff && filesToDiff.length || 0,
+            'workbench.filesToMerge': filesToMerge && filesToMerge.length || 0,
+            customKeybindingsCount: keybindingsService.customKeybindingsCount(),
+            theme: themeService.getColorTheme().id,
+            language,
+            pinnedViewlets: paneCompositeService.getPinnedPaneCompositeIds(ViewContainerLocation.Sidebar),
+            restoredViewlet: activeViewlet ? activeViewlet.getId() : undefined,
+            restoredEditors: editorService.visibleEditors.length,
+            startupKind: lifecycleService.startupKind
+        });
+        this._register(( new ErrorTelemetry(telemetryService)));
+        this._register(textFileService.files.onDidResolve(e => this.onTextFileModelResolved(e)));
+        this._register(textFileService.files.onDidSave(e => this.onTextFileModelSaved(e)));
+        this._register(lifecycleService.onDidShutdown(() => this.dispose()));
+    }
+    onTextFileModelResolved(e) {
+        const settingsType = this.getTypeIfSettings(e.model.resource);
+        if (settingsType) {
+            this.telemetryService.publicLog2('settingsRead', { settingsType });
+        }
+        else {
+            this.telemetryService.publicLog2('fileGet', this.getTelemetryData(e.model.resource, e.reason));
+        }
+    }
+    onTextFileModelSaved(e) {
+        const settingsType = this.getTypeIfSettings(e.model.resource);
+        if (settingsType) {
+            this.telemetryService.publicLog2('settingsWritten', { settingsType });
+        }
+        else {
+            this.telemetryService.publicLog2('filePUT', this.getTelemetryData(e.model.resource, e.reason));
+        }
+    }
+    getTypeIfSettings(resource) {
+        if (extname(resource) !== '.json') {
+            return '';
+        }
+        if (isEqual(resource, this.userDataProfileService.currentProfile.settingsResource)) {
+            return 'global-settings';
+        }
+        if (isEqual(resource, this.userDataProfileService.currentProfile.keybindingsResource)) {
+            return 'keybindings';
+        }
+        if (isEqualOrParent(resource, this.userDataProfileService.currentProfile.snippetsHome)) {
+            return 'snippets';
+        }
+        const folders = this.contextService.getWorkspace().folders;
+        for (const folder of folders) {
+            if (isEqualOrParent(resource, folder.toResource('.vscode'))) {
+                const filename = basename(resource);
+                if (TelemetryContribution_1.ALLOWLIST_WORKSPACE_JSON.indexOf(filename) > -1) {
+                    return `.vscode/${filename}`;
+                }
+            }
+        }
+        return '';
+    }
+    getTelemetryData(resource, reason) {
+        let ext = extname(resource);
+        const queryStringLocation = ext.indexOf('?');
+        ext = queryStringLocation !== -1 ? ext.substr(0, queryStringLocation) : ext;
+        const fileName = basename(resource);
+        const path = resource.scheme === Schemas.file ? resource.fsPath : resource.path;
+        const telemetryData = {
+            mimeType: ( new TelemetryTrustedValue(getMimeTypes(resource).join(', '))),
+            ext,
+            path: hash(path),
+            reason,
+            allowlistedjson: undefined
+        };
+        if (ext === '.json' && TelemetryContribution_1.ALLOWLIST_JSON.indexOf(fileName) > -1) {
+            telemetryData['allowlistedjson'] = fileName;
+        }
+        return telemetryData;
+    }
+};
+TelemetryContribution = TelemetryContribution_1 = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, ILifecycleService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IWorkbenchThemeService)),
+    ( __param(6, IWorkbenchEnvironmentService)),
+    ( __param(7, IUserDataProfileService)),
+    ( __param(8, IPaneCompositePartService)),
+    ( __param(9, ITextFileService))
+], TelemetryContribution));
+let ConfigurationTelemetryContribution = class ConfigurationTelemetryContribution extends Disposable {
+    constructor(configurationService, userDataProfilesService, telemetryService) {
+        super();
+        this.configurationService = configurationService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.telemetryService = telemetryService;
+        this.configurationRegistry = ( Registry.as(Extensions.Configuration));
+        const debouncedConfigService = Event.debounce(configurationService.onDidChangeConfiguration, (last, cur) => {
+            const newAffectedKeys = last ? ( new Set([...last.affectedKeys, ...cur.affectedKeys])) : cur.affectedKeys;
+            return { ...cur, affectedKeys: newAffectedKeys };
+        }, 1000, true);
+        this._register(debouncedConfigService(event => {
+            if (event.source !== ConfigurationTarget.DEFAULT) {
+                telemetryService.publicLog2('updateConfiguration', {
+                    configurationSource: ConfigurationTargetToString(event.source),
+                    configurationKeys: Array.from(event.affectedKeys)
+                });
+            }
+        }));
+        const { user, workspace } = ( configurationService.keys());
+        for (const setting of user) {
+            this.reportTelemetry(setting, ConfigurationTarget.USER_LOCAL);
+        }
+        for (const setting of workspace) {
+            this.reportTelemetry(setting, ConfigurationTarget.WORKSPACE);
+        }
+    }
+    getValueToReport(key, target) {
+        const inpsectData = this.configurationService.inspect(key);
+        const value = target === ConfigurationTarget.USER_LOCAL ? inpsectData.user?.value : inpsectData.workspace?.value;
+        if (isNumber(value) || isBoolean(value)) {
+            return ( value.toString());
+        }
+        const schema = this.configurationRegistry.getConfigurationProperties()[key];
+        if (isString(value)) {
+            if (schema?.enum?.includes(value)) {
+                return value;
+            }
+            return undefined;
+        }
+        if (Array.isArray(value)) {
+            if (value.every(v => isNumber(v) || isBoolean(v) || (isString(v) && schema?.enum?.includes(v)))) {
+                return JSON.stringify(value);
+            }
+        }
+        return undefined;
+    }
+    reportTelemetry(key, target) {
+        const source = ConfigurationTargetToString(target);
+        switch (key) {
+            case LayoutSettings.ACTIVITY_BAR_LOCATION:
+                this.telemetryService.publicLog2('workbench.activityBar.location', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case AutoUpdateConfigurationKey:
+                this.telemetryService.publicLog2('extensions.autoUpdate', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'files.autoSave':
+                this.telemetryService.publicLog2('files.autoSave', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'editor.stickyScroll.enabled':
+                this.telemetryService.publicLog2('editor.stickyScroll.enabled', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case KEYWORD_ACTIVIATION_SETTING_ID:
+                this.telemetryService.publicLog2('accessibility.voice.keywordActivation', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.zoomLevel':
+                this.telemetryService.publicLog2('window.zoomLevel', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.zoomPerWindow':
+                this.telemetryService.publicLog2('window.zoomPerWindow', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.titleBarStyle':
+                this.telemetryService.publicLog2('window.titleBarStyle', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.commandCenter':
+                this.telemetryService.publicLog2('window.commandCenter', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'chat.commandCenter.enabled':
+                this.telemetryService.publicLog2('chat.commandCenter.enabled', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.customTitleBarVisibility':
+                this.telemetryService.publicLog2('window.customTitleBarVisibility', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.nativeTabs':
+                this.telemetryService.publicLog2('window.nativeTabs', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'extensions.verifySignature':
+                this.telemetryService.publicLog2('extensions.verifySignature', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.systemColorTheme':
+                this.telemetryService.publicLog2('window.systemColorTheme', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.newWindowProfile':
+                {
+                    const valueToReport = this.getValueToReport(key, target);
+                    const settingValue = valueToReport === null ? 'null'
+                        : valueToReport === this.userDataProfilesService.defaultProfile.name
+                            ? 'default'
+                            : 'custom';
+                    this.telemetryService.publicLog2('window.newWindowProfile', { settingValue, source });
+                    return;
+                }
+            case AutoRestartConfigurationKey:
+                this.telemetryService.publicLog2('extensions.autoRestart', { settingValue: this.getValueToReport(key, target), source });
+                return;
+        }
+    }
+};
+ConfigurationTelemetryContribution = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IUserDataProfilesService)),
+    ( __param(2, ITelemetryService))
+], ConfigurationTelemetryContribution));
+const workbenchContributionRegistry = ( Registry.as(Extensions$1.Workbench));
+workbenchContributionRegistry.registerWorkbenchContribution(TelemetryContribution, LifecyclePhase.Restored);
+workbenchContributionRegistry.registerWorkbenchContribution(ConfigurationTelemetryContribution, LifecyclePhase.Eventually);
+
+export { TelemetryContribution };

package/vscode/src/vs/workbench/services/telemetry/browser/telemetryService.d.ts

@@ -0,0 +1,30 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ILoggerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/gdprTypings";
+import { ITelemetryData, TelemetryLevel } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IBrowserWorkbenchEnvironmentService } from "@codingame/monaco-vscode-411e0589-fa79-504b-b32c-80a88847b23a-common/vscode/vs/workbench/services/environment/browser/environmentService.service";
+import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+export declare class TelemetryService extends Disposable implements ITelemetryService {
+    readonly _serviceBrand: undefined;
+    private impl;
+    readonly sendErrorTelemetry = true;
+    get sessionId(): string;
+    get machineId(): string;
+    get sqmId(): string;
+    get devDeviceId(): string;
+    get firstSessionDate(): string;
+    get msftInternal(): boolean | undefined;
+    constructor(environmentService: IBrowserWorkbenchEnvironmentService, logService: ILogService, loggerService: ILoggerService, configurationService: IConfigurationService, storageService: IStorageService, productService: IProductService, remoteAgentService: IRemoteAgentService);
+    private initializeService;
+    setExperimentProperty(name: string, value: string): void;
+    get telemetryLevel(): TelemetryLevel;
+    publicLog(eventName: string, data?: ITelemetryData): void;
+    publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
+    publicLogError(errorEventName: string, data?: ITelemetryData): void;
+    publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
+}

package/vscode/src/vs/workbench/services/telemetry/browser/telemetryService.js

@@ -0,0 +1,93 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { ILogService, ILoggerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { OneDataSystemWebAppender } from '../../../../platform/telemetry/browser/1dsAppender.js';
+import { TELEMETRY_SETTING_ID, TelemetryLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { TelemetryLogAppender } from '../../../../platform/telemetry/common/telemetryLogAppender.js';
+import { TelemetryService as TelemetryService$1 } from '../../../../platform/telemetry/common/telemetryService.js';
+import { NullTelemetryService, supportsTelemetry, getTelemetryLevel, isInternalTelemetry, isLoggingOnly } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { IBrowserWorkbenchEnvironmentService } from '@codingame/monaco-vscode-411e0589-fa79-504b-b32c-80a88847b23a-common/vscode/vs/workbench/services/environment/browser/environmentService.service';
+import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { resolveWorkbenchCommonProperties } from './workbenchCommonProperties.js';
+
+let TelemetryService = class TelemetryService extends Disposable {
+    get sessionId() { return this.impl.sessionId; }
+    get machineId() { return this.impl.machineId; }
+    get sqmId() { return this.impl.sqmId; }
+    get devDeviceId() { return this.impl.devDeviceId; }
+    get firstSessionDate() { return this.impl.firstSessionDate; }
+    get msftInternal() { return this.impl.msftInternal; }
+    constructor(environmentService, logService, loggerService, configurationService, storageService, productService, remoteAgentService) {
+        super();
+        this.impl = NullTelemetryService;
+        this.sendErrorTelemetry = true;
+        this.impl = this.initializeService(environmentService, logService, loggerService, configurationService, storageService, productService, remoteAgentService);
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(TELEMETRY_SETTING_ID)) {
+                this.impl = this.initializeService(environmentService, logService, loggerService, configurationService, storageService, productService, remoteAgentService);
+            }
+        }));
+    }
+    initializeService(environmentService, logService, loggerService, configurationService, storageService, productService, remoteAgentService) {
+        const telemetrySupported = supportsTelemetry(productService, environmentService) && productService.aiConfig?.ariaKey;
+        if (telemetrySupported && getTelemetryLevel(configurationService) !== TelemetryLevel.NONE && this.impl === NullTelemetryService) {
+            const appenders = [];
+            const isInternal = isInternalTelemetry(productService, configurationService);
+            if (!isLoggingOnly(productService, environmentService)) {
+                if (remoteAgentService.getConnection() !== null) {
+                    const remoteTelemetryProvider = {
+                        log: remoteAgentService.logTelemetry.bind(remoteAgentService),
+                        flush: remoteAgentService.flushTelemetry.bind(remoteAgentService)
+                    };
+                    appenders.push(remoteTelemetryProvider);
+                }
+                else {
+                    appenders.push(( new OneDataSystemWebAppender(isInternal, 'monacoworkbench', null, productService.aiConfig?.ariaKey)));
+                }
+            }
+            appenders.push(( new TelemetryLogAppender(logService, loggerService, environmentService, productService)));
+            const config = {
+                appenders,
+                commonProperties: resolveWorkbenchCommonProperties(storageService, productService.commit, productService.version, isInternal, environmentService.remoteAuthority, productService.embedderIdentifier, productService.removeTelemetryMachineId, environmentService.options && environmentService.options.resolveCommonTelemetryProperties),
+                sendErrorTelemetry: this.sendErrorTelemetry,
+            };
+            return this._register(( new TelemetryService$1(config, configurationService, productService)));
+        }
+        return this.impl;
+    }
+    setExperimentProperty(name, value) {
+        return this.impl.setExperimentProperty(name, value);
+    }
+    get telemetryLevel() {
+        return this.impl.telemetryLevel;
+    }
+    publicLog(eventName, data) {
+        this.impl.publicLog(eventName, data);
+    }
+    publicLog2(eventName, data) {
+        this.publicLog(eventName, data);
+    }
+    publicLogError(errorEventName, data) {
+        this.impl.publicLog(errorEventName, data);
+    }
+    publicLogError2(eventName, data) {
+        this.publicLogError(eventName, data);
+    }
+};
+TelemetryService = ( __decorate([
+    ( __param(0, IBrowserWorkbenchEnvironmentService)),
+    ( __param(1, ILogService)),
+    ( __param(2, ILoggerService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IProductService)),
+    ( __param(6, IRemoteAgentService))
+], TelemetryService));
+
+export { TelemetryService };

package/vscode/src/vs/workbench/services/telemetry/browser/workbenchCommonProperties.d.ts

@@ -0,0 +1,5 @@
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ICommonProperties } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry";
+export declare function resolveWorkbenchCommonProperties(storageService: IStorageService, commit: string | undefined, version: string | undefined, isInternalTelemetry: boolean, remoteAuthority?: string, productIdentifier?: string, removeMachineId?: boolean, resolveAdditionalProperties?: () => {
+    [key: string]: any;
+}): ICommonProperties;

package/vscode/src/vs/workbench/services/telemetry/browser/workbenchCommonProperties.js

@@ -0,0 +1,65 @@
+
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { PlatformToString, platform, userAgent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { cleanRemoteAuthority } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { mixin } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { firstSessionDateStorageKey, lastSessionDateStorageKey, machineIdKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
+import { Gesture } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
+
+function cleanUserAgent(userAgent) {
+    return userAgent.replace(/(\d+\.\d+)(\.\d+)+/g, '$1');
+}
+function resolveWorkbenchCommonProperties(storageService, commit, version, isInternalTelemetry, remoteAuthority, productIdentifier, removeMachineId, resolveAdditionalProperties) {
+    const result = Object.create(null);
+    const firstSessionDate = storageService.get(firstSessionDateStorageKey, StorageScope.APPLICATION);
+    const lastSessionDate = storageService.get(lastSessionDateStorageKey, StorageScope.APPLICATION);
+    let machineId;
+    if (!removeMachineId) {
+        machineId = storageService.get(machineIdKey, StorageScope.APPLICATION);
+        if (!machineId) {
+            machineId = generateUuid();
+            storageService.store(machineIdKey, machineId, StorageScope.APPLICATION, StorageTarget.MACHINE);
+        }
+    }
+    else {
+        machineId = `Redacted-${productIdentifier ?? 'web'}`;
+    }
+    result['common.firstSessionDate'] = firstSessionDate;
+    result['common.lastSessionDate'] = lastSessionDate || '';
+    result['common.isNewSession'] = !lastSessionDate ? '1' : '0';
+    result['common.remoteAuthority'] = cleanRemoteAuthority(remoteAuthority);
+    result['common.machineId'] = machineId;
+    result['sessionID'] = generateUuid() + Date.now();
+    result['commitHash'] = commit;
+    result['version'] = version;
+    result['common.platform'] = PlatformToString(platform);
+    result['common.product'] = productIdentifier ?? 'web';
+    result['common.userAgent'] = userAgent ? cleanUserAgent(userAgent) : undefined;
+    result['common.isTouchDevice'] = String(Gesture.isTouchDevice());
+    if (isInternalTelemetry) {
+        result['common.msftInternal'] = isInternalTelemetry;
+    }
+    let seq = 0;
+    const startTime = Date.now();
+    Object.defineProperties(result, {
+        'timestamp': {
+            get: () => ( new Date()),
+            enumerable: true
+        },
+        'common.timesincesessionstart': {
+            get: () => Date.now() - startTime,
+            enumerable: true
+        },
+        'common.sequence': {
+            get: () => seq++,
+            enumerable: true
+        }
+    });
+    if (resolveAdditionalProperties) {
+        mixin(result, resolveAdditionalProperties());
+    }
+    return result;
+}
+
+export { resolveWorkbenchCommonProperties };