@codingame/monaco-vscode-log-service-override 1.83.9

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.d.ts

@@ -0,0 +1,2 @@
+export { default, registerAdditionalLogger } from './log.js';
+export { ConsoleLogger, ILogger } from 'vscode/vscode/vs/platform/log/common/log';

package/index.js

@@ -0,0 +1,2 @@
+export { default, registerAdditionalLogger } from './log.js';
+export { ConsoleLogger } from 'monaco-editor/esm/vs/platform/log/common/log.js';

package/log.d.ts

@@ -0,0 +1,14 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+import { LogLevel, ILogger } from 'vscode/vscode/vs/platform/log/common/log';
+export { ConsoleLogger, ILogger } from 'vscode/vscode/vs/platform/log/common/log';
+import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+/**
+ * @deprecated Provide logLevel via the services `initialize` function `configuration.developmentOptions.logLevel` parameter
+ */
+declare function getServiceOverride(logLevel?: LogLevel): IEditorOverrideServices;
+
+declare function registerAdditionalLogger(logger: ILogger): IDisposable;
+
+export { getServiceOverride as default, registerAdditionalLogger };

package/log.js

@@ -0,0 +1,56 @@
+import { __decorate, __param } from './external/tslib/tslib.es6.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILoggerService, ILogService, getLogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+export { ConsoleLogger } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { FileLoggerService } from './vscode/src/vs/platform/log/common/fileLog.js';
+import { LogService } from 'monaco-editor/esm/vs/platform/log/common/logService.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { windowLogId } from 'vscode/vscode/vs/workbench/services/log/common/logConstants';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import getServiceOverride$1 from '@codingame/monaco-vscode-environment-service-override';
+import { logsPath } from 'vscode/workbench';
+import './vscode/src/vs/workbench/contrib/logs/common/logs.contribution.js';
+import { checkServicesNotInitialized } from 'vscode/lifecycle';
+
+let _FileLoggerService = class _FileLoggerService extends FileLoggerService {
+    constructor(logLevel, fileService, environmentService) {
+        super(logLevel ?? getLogLevel(environmentService), logsPath, fileService);
+    }
+};
+_FileLoggerService = __decorate([
+    ( __param(1, IFileService)),
+    ( __param(2, IEnvironmentService))
+], _FileLoggerService);
+const otherLoggers = [];
+let _LogService = class _LogService extends LogService {
+    constructor(loggerService, environmentService) {
+        const logger = loggerService.createLogger(environmentService.logFile, { id: windowLogId, name: ( localizeWithPath('vs/workbench/browser/web.main', 'rendererLog', 'Window')) });
+        super(logger, otherLoggers);
+    }
+};
+_LogService = __decorate([
+    ( __param(0, ILoggerService)),
+    ( __param(1, IWorkbenchEnvironmentService))
+], _LogService);
+function getServiceOverride(logLevel) {
+    return {
+        ...getServiceOverride$1(),
+        [( ILoggerService.toString())]: new SyncDescriptor(_FileLoggerService, [logLevel], true),
+        [( ILogService.toString())]: new SyncDescriptor(_LogService, [], true)
+    };
+}
+function registerAdditionalLogger(logger) {
+    checkServicesNotInitialized();
+    otherLoggers.push(logger);
+    return toDisposable(() => {
+        const idx = otherLoggers.indexOf(logger);
+        if (idx >= 0) {
+            otherLoggers.splice(idx, 1);
+        }
+    });
+}
+
+export { getServiceOverride as default, registerAdditionalLogger };

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@codingame/monaco-vscode-log-service-override",
+  "version": "1.83.9",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - log service-override",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "vscode": "npm:@codingame/monaco-vscode-api@1.83.9",
+    "monaco-editor": "0.44.0",
+    "@codingame/monaco-vscode-environment-service-override": "1.83.9"
+  }
+}

package/vscode/src/vs/platform/log/common/fileLog.js

@@ -0,0 +1,107 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { joinPath, dirname, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ByteSize, IFileService, whenProviderRegistered } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { BufferLogger } from 'vscode/vscode/vs/platform/log/common/bufferLog';
+import { AbstractMessageLogger, LogLevel, AbstractLoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+
+const MAX_FILE_SIZE = 5 * ByteSize.MB;
+let FileLogger = class FileLogger extends AbstractMessageLogger {
+    constructor(resource, level, donotUseFormatters, fileService) {
+        super();
+        this.resource = resource;
+        this.donotUseFormatters = donotUseFormatters;
+        this.fileService = fileService;
+        this.backupIndex = 1;
+        this.buffer = '';
+        this.setLevel(level);
+        this.flushDelayer = ( new ThrottledDelayer(100 ));
+        this.initializePromise = this.initialize();
+    }
+    async flush() {
+        if (!this.buffer) {
+            return;
+        }
+        await this.initializePromise;
+        let content = await this.loadContent();
+        if (content.length > MAX_FILE_SIZE) {
+            await this.fileService.writeFile(this.getBackupResource(), VSBuffer.fromString(content));
+            content = '';
+        }
+        if (this.buffer) {
+            content += this.buffer;
+            this.buffer = '';
+            await this.fileService.writeFile(this.resource, VSBuffer.fromString(content));
+        }
+    }
+    async initialize() {
+        try {
+            await this.fileService.createFile(this.resource);
+        }
+        catch (error) {
+            if (error.fileOperationResult !== 3 ) {
+                throw error;
+            }
+        }
+    }
+    log(level, message) {
+        if (this.donotUseFormatters) {
+            this.buffer += message;
+        }
+        else {
+            this.buffer += `${this.getCurrentTimestamp()} [${this.stringifyLogLevel(level)}] ${message}\n`;
+        }
+        this.flushDelayer.trigger(() => this.flush());
+    }
+    getCurrentTimestamp() {
+        const toTwoDigits = (v) => v < 10 ? `0${v}` : v;
+        const toThreeDigits = (v) => v < 10 ? `00${v}` : v < 100 ? `0${v}` : v;
+        const currentTime = ( new Date());
+        return `${currentTime.getFullYear()}-${toTwoDigits(currentTime.getMonth() + 1)}-${toTwoDigits(currentTime.getDate())} ${toTwoDigits(currentTime.getHours())}:${toTwoDigits(currentTime.getMinutes())}:${toTwoDigits(currentTime.getSeconds())}.${toThreeDigits(currentTime.getMilliseconds())}`;
+    }
+    getBackupResource() {
+        this.backupIndex = this.backupIndex > 5 ? 1 : this.backupIndex;
+        return joinPath(dirname(this.resource), `${basename(this.resource)}_${this.backupIndex++}`);
+    }
+    async loadContent() {
+        try {
+            const content = await this.fileService.readFile(this.resource);
+            return ( content.value.toString());
+        }
+        catch (e) {
+            return '';
+        }
+    }
+    stringifyLogLevel(level) {
+        switch (level) {
+            case LogLevel.Debug: return 'debug';
+            case LogLevel.Error: return 'error';
+            case LogLevel.Info: return 'info';
+            case LogLevel.Trace: return 'trace';
+            case LogLevel.Warning: return 'warning';
+        }
+        return '';
+    }
+};
+FileLogger = ( __decorate([
+    ( __param(3, IFileService))
+], FileLogger));
+class FileLoggerService extends AbstractLoggerService {
+    constructor(logLevel, logsHome, fileService) {
+        super(logLevel, logsHome);
+        this.fileService = fileService;
+    }
+    doCreateLogger(resource, logLevel, options) {
+        const logger = ( new BufferLogger(logLevel));
+        whenProviderRegistered(resource, this.fileService).then(() => logger.logger = ( new FileLogger(
+            resource,
+            logger.getLevel(),
+            !!options?.donotUseFormatters,
+            this.fileService
+        )));
+        return logger;
+    }
+}
+
+export { FileLoggerService };

package/vscode/src/vs/workbench/contrib/logs/common/defaultLogLevels.js

@@ -0,0 +1,5 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+
+const IDefaultLogLevelsService = ( createDecorator('IDefaultLogLevelsService'));
+
+export { IDefaultLogLevelsService };

package/vscode/src/vs/workbench/contrib/logs/common/logs.contribution.js

@@ -0,0 +1,217 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { SetLogLevelAction } from './logsActions.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { whenProviderRegistered, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { Extensions as Extensions$1, IOutputService } from 'vscode/vscode/vs/workbench/services/output/common/output';
+import { Disposable, DisposableMap, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { CONTEXT_LOG_LEVEL, LogLevelToString, isLogLevel, ILogService, ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { showWindowLogActionId, windowLogId } from 'vscode/vscode/vs/workbench/services/log/common/logConstants';
+import { createCancelablePromise, timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { isCancellationError, getErrorMessage, CancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IDefaultLogLevelsService } from './defaultLogLevels.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { CounterSet } from 'monaco-editor/esm/vs/base/common/map.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: SetLogLevelAction.ID,
+            title: SetLogLevelAction.TITLE,
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run(servicesAccessor) {
+        return servicesAccessor.get(IInstantiationService).createInstance(SetLogLevelAction, SetLogLevelAction.ID, SetLogLevelAction.TITLE.value).run();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.setDefaultLogLevel',
+            title: { value: ( nls.localizeWithPath(
+                'vs/workbench/contrib/logs/common/logs.contribution',
+                'setDefaultLogLevel',
+                "Set Default Log Level"
+            )), original: 'Set Default Log Level' },
+            category: Categories.Developer,
+        });
+    }
+    run(servicesAccessor, logLevel, extensionId) {
+        return servicesAccessor.get(IDefaultLogLevelsService).setDefaultLogLevel(logLevel, extensionId);
+    }
+});
+let LogOutputChannels = class LogOutputChannels extends Disposable {
+    constructor(logService, loggerService, contextKeyService, fileService, uriIdentityService) {
+        super();
+        this.logService = logService;
+        this.loggerService = loggerService;
+        this.contextKeyService = contextKeyService;
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+        this.contextKeys = ( new CounterSet());
+        this.outputChannelRegistry = ( Registry.as(Extensions$1.OutputChannels));
+        this.loggerDisposables = this._register(( new DisposableMap()));
+        const contextKey = CONTEXT_LOG_LEVEL.bindTo(contextKeyService);
+        contextKey.set(LogLevelToString(loggerService.getLogLevel()));
+        loggerService.onDidChangeLogLevel(e => {
+            if (isLogLevel(e)) {
+                contextKey.set(LogLevelToString(loggerService.getLogLevel()));
+            }
+        });
+        this.onDidAddLoggers(loggerService.getRegisteredLoggers());
+        this._register(loggerService.onDidChangeLoggers(({ added, removed }) => {
+            this.onDidAddLoggers(added);
+            this.onDidRemoveLoggers(removed);
+        }));
+        this._register(loggerService.onDidChangeVisibility(([resource, visibility]) => {
+            const logger = loggerService.getRegisteredLogger(resource);
+            if (logger) {
+                if (visibility) {
+                    this.registerLogChannel(logger);
+                }
+                else {
+                    this.deregisterLogChannel(logger);
+                }
+            }
+        }));
+        this.registerShowWindowLogAction();
+        this._register(Event.filter(contextKeyService.onDidChangeContext, e => e.affectsSome(this.contextKeys))(() => this.onDidChangeContext()));
+    }
+    onDidAddLoggers(loggers) {
+        for (const logger of loggers) {
+            if (logger.when) {
+                const contextKeyExpr = ContextKeyExpr.deserialize(logger.when);
+                if (contextKeyExpr) {
+                    for (const key of ( contextKeyExpr.keys())) {
+                        this.contextKeys.add(key);
+                    }
+                    if (!this.contextKeyService.contextMatchesRules(contextKeyExpr)) {
+                        continue;
+                    }
+                }
+            }
+            if (logger.hidden) {
+                continue;
+            }
+            this.registerLogChannel(logger);
+        }
+    }
+    onDidChangeContext() {
+        for (const logger of this.loggerService.getRegisteredLoggers()) {
+            if (logger.when) {
+                if (this.contextKeyService.contextMatchesRules(ContextKeyExpr.deserialize(logger.when))) {
+                    this.registerLogChannel(logger);
+                }
+                else {
+                    this.deregisterLogChannel(logger);
+                }
+            }
+        }
+    }
+    onDidRemoveLoggers(loggers) {
+        for (const logger of loggers) {
+            if (logger.when) {
+                const contextKeyExpr = ContextKeyExpr.deserialize(logger.when);
+                if (contextKeyExpr) {
+                    for (const key of ( contextKeyExpr.keys())) {
+                        this.contextKeys.delete(key);
+                    }
+                }
+            }
+            this.deregisterLogChannel(logger);
+        }
+    }
+    registerLogChannel(logger) {
+        const channel = this.outputChannelRegistry.getChannel(logger.id);
+        if (channel && this.uriIdentityService.extUri.isEqual(channel.file, logger.resource)) {
+            return;
+        }
+        const disposables = ( new DisposableStore());
+        const promise = createCancelablePromise(async (token) => {
+            await whenProviderRegistered(logger.resource, this.fileService);
+            try {
+                await this.whenFileExists(logger.resource, 1, token);
+                const existingChannel = this.outputChannelRegistry.getChannel(logger.id);
+                const remoteLogger = existingChannel?.file?.scheme === Schemas.vscodeRemote ? this.loggerService.getRegisteredLogger(existingChannel.file) : undefined;
+                if (remoteLogger) {
+                    this.deregisterLogChannel(remoteLogger);
+                }
+                const hasToAppendRemote = existingChannel && logger.resource.scheme === Schemas.vscodeRemote;
+                const id = hasToAppendRemote ? `${logger.id}.remote` : logger.id;
+                const label = hasToAppendRemote ? ( nls.localizeWithPath(
+                    'vs/workbench/contrib/logs/common/logs.contribution',
+                    'remote name',
+                    "{0} (Remote)",
+                    logger.name ?? logger.id
+                )) : logger.name ?? logger.id;
+                this.outputChannelRegistry.registerChannel({ id, label, file: logger.resource, log: true, extensionId: logger.extensionId });
+                disposables.add(toDisposable(() => this.outputChannelRegistry.removeChannel(id)));
+                if (remoteLogger) {
+                    this.registerLogChannel(remoteLogger);
+                }
+            }
+            catch (error) {
+                if (!isCancellationError(error)) {
+                    this.logService.error('Error while registering log channel', ( logger.resource.toString()), getErrorMessage(error));
+                }
+            }
+        });
+        disposables.add(toDisposable(() => promise.cancel()));
+        this.loggerDisposables.set(( logger.resource.toString()), disposables);
+    }
+    deregisterLogChannel(logger) {
+        this.loggerDisposables.deleteAndDispose(( logger.resource.toString()));
+    }
+    async whenFileExists(file, trial, token) {
+        const exists = await this.fileService.exists(file);
+        if (exists) {
+            return;
+        }
+        if (token.isCancellationRequested) {
+            throw new CancellationError();
+        }
+        if (trial > 10) {
+            throw new Error(`Timed out while waiting for file to be created`);
+        }
+        this.logService.debug(`[Registering Log Channel] File does not exist. Waiting for 1s to retry.`, ( file.toString()));
+        await timeout(1000, token);
+        await this.whenFileExists(file, trial + 1, token);
+    }
+    registerShowWindowLogAction() {
+        registerAction2(class ShowWindowLogAction extends Action2 {
+            constructor() {
+                super({
+                    id: showWindowLogActionId,
+                    title: { value: ( nls.localizeWithPath(
+                        'vs/workbench/contrib/logs/common/logs.contribution',
+                        'show window log',
+                        "Show Window Log"
+                    )), original: 'Show Window Log' },
+                    category: Categories.Developer,
+                    f1: true
+                });
+            }
+            async run(servicesAccessor) {
+                const outputService = servicesAccessor.get(IOutputService);
+                outputService.showChannel(windowLogId);
+            }
+        });
+    }
+};
+LogOutputChannels = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, ILoggerService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IUriIdentityService))
+], LogOutputChannels));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(LogOutputChannels, 3 );

package/vscode/src/vs/workbench/contrib/logs/common/logsActions.js

@@ -0,0 +1,250 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { isLogLevel, LogLevel, ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { basename, dirname, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IOutputService } from 'vscode/vscode/vs/workbench/services/output/common/output';
+import { telemetryLogId, extensionTelemetryLogChannelId } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { IDefaultLogLevelsService } from './defaultLogLevels.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+
+let SetLogLevelAction = class SetLogLevelAction extends Action {
+    static { this.ID = 'workbench.action.setLogLevel'; }
+    static { this.TITLE = { value: ( nls.localizeWithPath(
+        'vs/workbench/contrib/logs/common/logsActions',
+        'setLogLevel',
+        "Set Log Level..."
+    )), original: 'Set Log Level...' }; }
+    constructor(id, label, quickInputService, loggerService, outputService, defaultLogLevelsService) {
+        super(id, label);
+        this.quickInputService = quickInputService;
+        this.loggerService = loggerService;
+        this.outputService = outputService;
+        this.defaultLogLevelsService = defaultLogLevelsService;
+    }
+    async run() {
+        const logLevelOrChannel = await this.selectLogLevelOrChannel();
+        if (logLevelOrChannel !== null) {
+            if (isLogLevel(logLevelOrChannel)) {
+                this.loggerService.setLogLevel(logLevelOrChannel);
+            }
+            else {
+                await this.setLogLevelForChannel(logLevelOrChannel);
+            }
+        }
+    }
+    async selectLogLevelOrChannel() {
+        const defaultLogLevels = await this.defaultLogLevelsService.getDefaultLogLevels();
+        const extensionLogs = [], logs = [];
+        const logLevel = this.loggerService.getLogLevel();
+        for (const channel of this.outputService.getChannelDescriptors()) {
+            if (!channel.log || !channel.file || channel.id === telemetryLogId || channel.id === extensionTelemetryLogChannelId) {
+                continue;
+            }
+            const channelLogLevel = this.loggerService.getLogLevel(channel.file) ?? logLevel;
+            const item = { id: channel.id, resource: channel.file, label: channel.label, description: channelLogLevel !== logLevel ? this.getLabel(channelLogLevel) : undefined, extensionId: channel.extensionId };
+            if (channel.extensionId) {
+                extensionLogs.push(item);
+            }
+            else {
+                logs.push(item);
+            }
+        }
+        const entries = [];
+        entries.push({ type: 'separator', label: ( nls.localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'all', "All")) });
+        entries.push(...this.getLogLevelEntries(defaultLogLevels.default, this.loggerService.getLogLevel(), true));
+        if (extensionLogs.length) {
+            entries.push({ type: 'separator', label: ( nls.localizeWithPath(
+                'vs/workbench/contrib/logs/common/logsActions',
+                'extensionLogs',
+                "Extension Logs"
+            )) });
+            entries.push(...extensionLogs.sort((a, b) => a.label.localeCompare(b.label)));
+        }
+        entries.push({ type: 'separator', label: ( nls.localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'loggers', "Logs")) });
+        entries.push(...logs.sort((a, b) => a.label.localeCompare(b.label)));
+        return ( new Promise((resolve, reject) => {
+            const disposables = ( new DisposableStore());
+            const quickPick = this.quickInputService.createQuickPick();
+            quickPick.placeholder = ( nls.localizeWithPath(
+                'vs/workbench/contrib/logs/common/logsActions',
+                'selectlog',
+                "Set Log Level"
+            ));
+            quickPick.items = entries;
+            let selectedItem;
+            disposables.add(quickPick.onDidTriggerItemButton(e => {
+                quickPick.hide();
+                this.defaultLogLevelsService.setDefaultLogLevel(e.item.level);
+            }));
+            disposables.add(quickPick.onDidAccept(e => {
+                selectedItem = quickPick.selectedItems[0];
+                quickPick.hide();
+            }));
+            disposables.add(quickPick.onDidHide(() => {
+                const result = selectedItem ? selectedItem.level ?? selectedItem : null;
+                disposables.dispose();
+                resolve(result);
+            }));
+            quickPick.show();
+        }));
+    }
+    async setLogLevelForChannel(logChannel) {
+        const defaultLogLevels = await this.defaultLogLevelsService.getDefaultLogLevels();
+        const defaultLogLevel = defaultLogLevels.extensions.find(e => e[0] === logChannel.extensionId?.toLowerCase())?.[1] ?? defaultLogLevels.default;
+        const currentLogLevel = this.loggerService.getLogLevel(logChannel.resource) ?? defaultLogLevel;
+        const entries = this.getLogLevelEntries(defaultLogLevel, currentLogLevel, !!logChannel.extensionId);
+        return ( new Promise((resolve, reject) => {
+            const disposables = ( new DisposableStore());
+            const quickPick = this.quickInputService.createQuickPick();
+            quickPick.placeholder = logChannel ? ( nls.localizeWithPath(
+                'vs/workbench/contrib/logs/common/logsActions',
+                'selectLogLevelFor',
+                " {0}: Select log level",
+                logChannel?.label
+            )) : ( nls.localizeWithPath(
+                'vs/workbench/contrib/logs/common/logsActions',
+                'selectLogLevel',
+                "Select log level"
+            ));
+            quickPick.items = entries;
+            quickPick.activeItems = [entries[this.loggerService.getLogLevel()]];
+            let selectedItem;
+            disposables.add(quickPick.onDidTriggerItemButton(e => {
+                quickPick.hide();
+                this.defaultLogLevelsService.setDefaultLogLevel(e.item.level, logChannel.extensionId);
+            }));
+            disposables.add(quickPick.onDidAccept(e => {
+                selectedItem = quickPick.selectedItems[0];
+                quickPick.hide();
+            }));
+            disposables.add(quickPick.onDidHide(() => {
+                if (selectedItem) {
+                    this.loggerService.setLogLevel(logChannel.resource, selectedItem.level);
+                }
+                disposables.dispose();
+                resolve();
+            }));
+            quickPick.show();
+        }));
+    }
+    getLogLevelEntries(defaultLogLevel, currentLogLevel, canSetDefaultLogLevel) {
+        const button = canSetDefaultLogLevel ? { iconClass: ThemeIcon.asClassName(Codicon.checkAll), tooltip: ( nls.localizeWithPath(
+            'vs/workbench/contrib/logs/common/logsActions',
+            'resetLogLevel',
+            "Set as Default Log Level"
+        )) } : undefined;
+        return [
+            { label: this.getLabel(LogLevel.Trace, currentLogLevel), level: LogLevel.Trace, description: this.getDescription(LogLevel.Trace, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Trace ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Debug, currentLogLevel), level: LogLevel.Debug, description: this.getDescription(LogLevel.Debug, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Debug ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Info, currentLogLevel), level: LogLevel.Info, description: this.getDescription(LogLevel.Info, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Info ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Warning, currentLogLevel), level: LogLevel.Warning, description: this.getDescription(LogLevel.Warning, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Warning ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Error, currentLogLevel), level: LogLevel.Error, description: this.getDescription(LogLevel.Error, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Error ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Off, currentLogLevel), level: LogLevel.Off, description: this.getDescription(LogLevel.Off, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Off ? [button] : undefined },
+        ];
+    }
+    getLabel(level, current) {
+        let label;
+        switch (level) {
+            case LogLevel.Trace:
+                label = ( nls.localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'trace', "Trace"));
+                break;
+            case LogLevel.Debug:
+                label = ( nls.localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'debug', "Debug"));
+                break;
+            case LogLevel.Info:
+                label = ( nls.localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'info', "Info"));
+                break;
+            case LogLevel.Warning:
+                label = ( nls.localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'warn', "Warning"));
+                break;
+            case LogLevel.Error:
+                label = ( nls.localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'err', "Error"));
+                break;
+            case LogLevel.Off:
+                label = ( nls.localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'off', "Off"));
+                break;
+        }
+        return level === current ? `$(check) ${label}` : label;
+    }
+    getDescription(level, defaultLogLevel) {
+        return defaultLogLevel === level ? ( nls.localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'default', "Default")) : undefined;
+    }
+};
+SetLogLevelAction = ( __decorate([
+    ( __param(2, IQuickInputService)),
+    ( __param(3, ILoggerService)),
+    ( __param(4, IOutputService)),
+    ( __param(5, IDefaultLogLevelsService))
+], SetLogLevelAction));
+(class OpenWindowSessionLogFileAction extends Action {
+    static { this.ID = 'workbench.action.openSessionLogFile'; }
+    static { this.TITLE = { value: ( nls.localizeWithPath(
+        'vs/workbench/contrib/logs/common/logsActions',
+        'openSessionLogFile',
+        "Open Window Log File (Session)..."
+    )), original: 'Open Window Log File (Session)...' }; }
+    constructor(id, label, environmentService, fileService, quickInputService, editorService) {
+        super(id, label);
+        this.environmentService = environmentService;
+        this.fileService = fileService;
+        this.quickInputService = quickInputService;
+        this.editorService = editorService;
+    }
+    async run() {
+        const sessionResult = await this.quickInputService.pick(this.getSessions().then(sessions => ( sessions.map((s, index) => ({
+            id: ( s.toString()),
+            label: basename(s),
+            description: index === 0 ? ( nls.localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'current', "Current")) : undefined
+        })))), {
+            canPickMany: false,
+            placeHolder: ( nls.localizeWithPath(
+                'vs/workbench/contrib/logs/common/logsActions',
+                'sessions placeholder',
+                "Select Session"
+            ))
+        });
+        if (sessionResult) {
+            const logFileResult = await this.quickInputService.pick(this.getLogFiles(( URI.parse(sessionResult.id))).then(logFiles => ( logFiles.map(s => ({
+                id: ( s.toString()),
+                label: basename(s)
+            })))), {
+                canPickMany: false,
+                placeHolder: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/logs/common/logsActions',
+                    'log placeholder',
+                    "Select Log file"
+                ))
+            });
+            if (logFileResult) {
+                return this.editorService.openEditor({ resource: ( URI.parse(logFileResult.id)), options: { pinned: true } }).then(() => undefined);
+            }
+        }
+    }
+    async getSessions() {
+        const logsPath = this.environmentService.logsHome.with({ scheme: this.environmentService.logFile.scheme });
+        const result = [logsPath];
+        const stat = await this.fileService.resolve(dirname(logsPath));
+        if (stat.children) {
+            result.push(...( stat.children
+                .filter(stat => !isEqual(stat.resource, logsPath) && stat.isDirectory && /^\d{8}T\d{6}$/.test(stat.name))
+                .sort()
+                .reverse()
+                .map(d => d.resource)));
+        }
+        return result;
+    }
+    async getLogFiles(session) {
+        const stat = await this.fileService.resolve(session);
+        if (stat.children) {
+            return ( stat.children.filter(stat => !stat.isDirectory).map(stat => stat.resource));
+        }
+        return [];
+    }
+});
+
+export { SetLogLevelAction };