@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/performance/browser/perfviewEditor.js

@@ -0,0 +1,340 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { URI } from '../../../../base/common/uri.js';
+import { TextResourceEditorInput } from '../../../common/editor/textResourceEditorInput.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { StartupKindToString, ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { ITimerService } from '../../../services/timer/browser/timerService.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { dispose } from '../../../../base/common/lifecycle.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { writeTransientState } from '../../codeEditor/browser/toggleWordWrap.js';
+import { LoaderStats } from '../../../../base/common/amd.js';
+import { IProductService } from '../../../../platform/product/common/productService.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ByteSize, IFileService } from '../../../../platform/files/common/files.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { isWeb } from '../../../../base/common/platform.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { ITerminalService } from '../../terminal/browser/terminal.js';
+import { ITextResourceConfigurationService } from '../../../../editor/common/services/textResourceConfiguration.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { getWorkbenchContribution, Extensions } from '../../../common/contributions.js';
+import { ICustomEditorLabelService } from '../../../services/editor/common/customEditorLabelService.js';
+var PerfviewContrib_1, PerfviewInput_1;
+let PerfviewContrib = class PerfviewContrib {
+    static { PerfviewContrib_1 = this; }
+    static get() {
+        return getWorkbenchContribution(PerfviewContrib_1.ID);
+    }
+    static { this.ID = 'workbench.contrib.perfview'; }
+    constructor(_instaService, textModelResolverService) {
+        this._instaService = _instaService;
+        this._inputUri = ( URI.from({ scheme: 'perf', path: 'Startup Performance' }));
+        this._registration = textModelResolverService.registerTextModelContentProvider('perf', _instaService.createInstance(PerfModelContentProvider));
+    }
+    dispose() {
+        this._registration.dispose();
+    }
+    getInputUri() {
+        return this._inputUri;
+    }
+    getEditorInput() {
+        return this._instaService.createInstance(PerfviewInput);
+    }
+};
+PerfviewContrib = PerfviewContrib_1 = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ITextModelService))
+], PerfviewContrib));
+let PerfviewInput = class PerfviewInput extends TextResourceEditorInput {
+    static { PerfviewInput_1 = this; }
+    static { this.Id = 'PerfviewInput'; }
+    get typeId() {
+        return PerfviewInput_1.Id;
+    }
+    constructor(textModelResolverService, textFileService, editorService, fileService, labelService, filesConfigurationService, textResourceConfigurationService, customEditorLabelService) {
+        super(PerfviewContrib.get().getInputUri(), ( localizeWithPath(
+            'vs/workbench/contrib/performance/browser/perfviewEditor',
+            'name',
+            "Startup Performance"
+        )), undefined, undefined, undefined, textModelResolverService, textFileService, editorService, fileService, labelService, filesConfigurationService, textResourceConfigurationService, customEditorLabelService);
+    }
+};
+PerfviewInput = PerfviewInput_1 = ( __decorate([
+    ( __param(0, ITextModelService)),
+    ( __param(1, ITextFileService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, IFileService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, IFilesConfigurationService)),
+    ( __param(6, ITextResourceConfigurationService)),
+    ( __param(7, ICustomEditorLabelService))
+], PerfviewInput));
+let PerfModelContentProvider = class PerfModelContentProvider {
+    constructor(_modelService, _languageService, _editorService, _lifecycleService, _timerService, _extensionService, _productService, _terminalService) {
+        this._modelService = _modelService;
+        this._languageService = _languageService;
+        this._editorService = _editorService;
+        this._lifecycleService = _lifecycleService;
+        this._timerService = _timerService;
+        this._extensionService = _extensionService;
+        this._productService = _productService;
+        this._terminalService = _terminalService;
+        this._modelDisposables = [];
+    }
+    provideTextContent(resource) {
+        if (!this._model || this._model.isDisposed()) {
+            dispose(this._modelDisposables);
+            const langId = this._languageService.createById('markdown');
+            this._model = this._modelService.getModel(resource) || this._modelService.createModel('Loading...', langId, resource);
+            this._modelDisposables.push(langId.onDidChange(e => {
+                this._model?.setLanguage(e);
+            }));
+            this._modelDisposables.push(this._extensionService.onDidChangeExtensionsStatus(this._updateModel, this));
+            writeTransientState(this._model, { wordWrapOverride: 'off' }, this._editorService);
+        }
+        this._updateModel();
+        return Promise.resolve(this._model);
+    }
+    _updateModel() {
+        Promise.all([
+            this._timerService.whenReady(),
+            this._lifecycleService.when(4 ),
+            this._extensionService.whenInstalledExtensionsRegistered(),
+            this._terminalService.whenConnected
+        ]).then(() => {
+            if (this._model && !this._model.isDisposed()) {
+                const stats = LoaderStats.get();
+                const md = ( new MarkdownBuilder());
+                this._addSummary(md);
+                md.blank();
+                this._addSummaryTable(md, stats);
+                md.blank();
+                this._addExtensionsTable(md);
+                md.blank();
+                this._addPerfMarksTable('Terminal Stats', md, this._timerService.getPerformanceMarks().find(e => e[0] === 'renderer')?.[1].filter(e => e.name.startsWith('code/terminal/')));
+                md.blank();
+                this._addWorkbenchContributionsPerfMarksTable(md);
+                md.blank();
+                this._addRawPerfMarks(md);
+                md.blank();
+                this._addResourceTimingStats(md);
+                this._model.setValue(md.value);
+            }
+        });
+    }
+    _addSummary(md) {
+        const metrics = this._timerService.startupMetrics;
+        md.heading(2, 'System Info');
+        md.li(`${this._productService.nameShort}: ${this._productService.version} (${this._productService.commit || '0000000'})`);
+        md.li(`OS: ${metrics.platform}(${metrics.release})`);
+        if (metrics.cpus) {
+            md.li(`CPUs: ${metrics.cpus.model}(${metrics.cpus.count} x ${metrics.cpus.speed})`);
+        }
+        if (typeof metrics.totalmem === 'number' && typeof metrics.freemem === 'number') {
+            md.li(`Memory(System): ${(metrics.totalmem / (ByteSize.GB)).toFixed(2)} GB(${(metrics.freemem / (ByteSize.GB)).toFixed(2)}GB free)`);
+        }
+        if (metrics.meminfo) {
+            md.li(`Memory(Process): ${(metrics.meminfo.workingSetSize / ByteSize.KB).toFixed(2)} MB working set(${(metrics.meminfo.privateBytes / ByteSize.KB).toFixed(2)}MB private, ${(metrics.meminfo.sharedBytes / ByteSize.KB).toFixed(2)}MB shared)`);
+        }
+        md.li(`VM(likelihood): ${metrics.isVMLikelyhood}%`);
+        md.li(`Initial Startup: ${metrics.initialStartup}`);
+        md.li(`Has ${metrics.windowCount - 1} other windows`);
+        md.li(`Screen Reader Active: ${metrics.hasAccessibilitySupport}`);
+        md.li(`Empty Workspace: ${metrics.emptyWorkbench}`);
+    }
+    _addSummaryTable(md, stats) {
+        const metrics = this._timerService.startupMetrics;
+        const contribTimings = ( Registry.as(Extensions.Workbench)).timings;
+        const table = [];
+        table.push(['start => app.isReady', metrics.timers.ellapsedAppReady, '[main]', `initial startup: ${metrics.initialStartup}`]);
+        table.push(['nls:start => nls:end', metrics.timers.ellapsedNlsGeneration, '[main]', `initial startup: ${metrics.initialStartup}`]);
+        table.push(['require(main.bundle.js)', metrics.timers.ellapsedLoadMainBundle, '[main]', `initial startup: ${metrics.initialStartup}`]);
+        table.push(['start crash reporter', metrics.timers.ellapsedCrashReporter, '[main]', `initial startup: ${metrics.initialStartup}`]);
+        table.push(['serve main IPC handle', metrics.timers.ellapsedMainServer, '[main]', `initial startup: ${metrics.initialStartup}`]);
+        table.push(['create window', metrics.timers.ellapsedWindowCreate, '[main]', `initial startup: ${metrics.initialStartup}, ${metrics.initialStartup ? `state: ${metrics.timers.ellapsedWindowRestoreState}ms, widget: ${metrics.timers.ellapsedBrowserWindowCreate}ms, show: ${metrics.timers.ellapsedWindowMaximize}ms` : ''}`]);
+        table.push(['app.isReady => window.loadUrl()', metrics.timers.ellapsedWindowLoad, '[main]', `initial startup: ${metrics.initialStartup}`]);
+        table.push(['window.loadUrl() => begin to require(workbench.desktop.main.js)', metrics.timers.ellapsedWindowLoadToRequire, '[main->renderer]', StartupKindToString(metrics.windowKind)]);
+        table.push(['require(workbench.desktop.main.js)', metrics.timers.ellapsedRequire, '[renderer]', `cached data: ${(metrics.didUseCachedData ? 'YES' : 'NO')}${stats ? `, node_modules took ${stats.nodeRequireTotal}ms` : ''}`]);
+        table.push(['wait for window config', metrics.timers.ellapsedWaitForWindowConfig, '[renderer]', undefined]);
+        table.push(['init storage (global & workspace)', metrics.timers.ellapsedStorageInit, '[renderer]', undefined]);
+        table.push(['init workspace service', metrics.timers.ellapsedWorkspaceServiceInit, '[renderer]', undefined]);
+        if (isWeb) {
+            table.push(['init settings and global state from settings sync service', metrics.timers.ellapsedRequiredUserDataInit, '[renderer]', undefined]);
+            table.push(['init keybindings, snippets & extensions from settings sync service', metrics.timers.ellapsedOtherUserDataInit, '[renderer]', undefined]);
+        }
+        table.push(['register extensions & spawn extension host', metrics.timers.ellapsedExtensions, '[renderer]', undefined]);
+        table.push(['restore viewlet', metrics.timers.ellapsedViewletRestore, '[renderer]', metrics.viewletId]);
+        table.push(['restore panel', metrics.timers.ellapsedPanelRestore, '[renderer]', metrics.panelId]);
+        table.push(['restore & resolve visible editors', metrics.timers.ellapsedEditorRestore, '[renderer]', `${metrics.editorIds.length}: ${metrics.editorIds.join(', ')}`]);
+        table.push(['create workbench contributions', metrics.timers.ellapsedWorkbenchContributions, '[renderer]', `${(contribTimings.get(1 )?.length ?? 0) + (contribTimings.get(1 )?.length ?? 0)} blocking startup`]);
+        table.push(['overall workbench load', metrics.timers.ellapsedWorkbench, '[renderer]', undefined]);
+        table.push(['workbench ready', metrics.ellapsed, '[main->renderer]', undefined]);
+        table.push(['renderer ready', metrics.timers.ellapsedRenderer, '[renderer]', undefined]);
+        table.push(['shared process connection ready', metrics.timers.ellapsedSharedProcesConnected, '[renderer->sharedprocess]', undefined]);
+        table.push(['extensions registered', metrics.timers.ellapsedExtensionsReady, '[renderer]', undefined]);
+        md.heading(2, 'Performance Marks');
+        md.table(['What', 'Duration', 'Process', 'Info'], table);
+    }
+    _addExtensionsTable(md) {
+        const eager = [];
+        const normal = [];
+        const extensionsStatus = this._extensionService.getExtensionsStatus();
+        for (const id in extensionsStatus) {
+            const { activationTimes: times } = extensionsStatus[id];
+            if (!times) {
+                continue;
+            }
+            if (times.activationReason.startup) {
+                eager.push([id, times.activationReason.startup, times.codeLoadingTime, times.activateCallTime, times.activateResolvedTime, times.activationReason.activationEvent, times.activationReason.extensionId.value]);
+            }
+            else {
+                normal.push([id, times.activationReason.startup, times.codeLoadingTime, times.activateCallTime, times.activateResolvedTime, times.activationReason.activationEvent, times.activationReason.extensionId.value]);
+            }
+        }
+        const table = eager.concat(normal);
+        if (table.length > 0) {
+            md.heading(2, 'Extension Activation Stats');
+            md.table(['Extension', 'Eager', 'Load Code', 'Call Activate', 'Finish Activate', 'Event', 'By'], table);
+        }
+    }
+    _addPerfMarksTable(name, md, marks) {
+        if (!marks) {
+            return;
+        }
+        const table = [];
+        let lastStartTime = -1;
+        let total = 0;
+        for (const { name, startTime } of marks) {
+            const delta = lastStartTime !== -1 ? startTime - lastStartTime : 0;
+            total += delta;
+            table.push([name, Math.round(startTime), Math.round(delta), Math.round(total)]);
+            lastStartTime = startTime;
+        }
+        if (name) {
+            md.heading(2, name);
+        }
+        md.table(['Name', 'Timestamp', 'Delta', 'Total'], table);
+    }
+    _addWorkbenchContributionsPerfMarksTable(md) {
+        md.heading(2, 'Workbench Contributions Blocking Restore');
+        const timings = ( Registry.as(Extensions.Workbench)).timings;
+        md.li(`Total (LifecyclePhase.Starting): ${timings.get(1 )?.length} (${timings.get(1 )?.reduce((p, c) => p + c[1], 0)}ms)`);
+        md.li(`Total (LifecyclePhase.Ready): ${timings.get(2 )?.length} (${timings.get(2 )?.reduce((p, c) => p + c[1], 0)}ms)`);
+        md.blank();
+        const marks = this._timerService.getPerformanceMarks().find(e => e[0] === 'renderer')?.[1].filter(e => e.name.startsWith('code/willCreateWorkbenchContribution/1') ||
+            e.name.startsWith('code/didCreateWorkbenchContribution/1') ||
+            e.name.startsWith('code/willCreateWorkbenchContribution/2') ||
+            e.name.startsWith('code/didCreateWorkbenchContribution/2'));
+        this._addPerfMarksTable(undefined, md, marks);
+    }
+    _addRawPerfMarks(md) {
+        for (const [source, marks] of this._timerService.getPerformanceMarks()) {
+            md.heading(2, `Raw Perf Marks: ${source}`);
+            md.value += '```\n';
+            md.value += `Name\tTimestamp\tDelta\tTotal\n`;
+            let lastStartTime = -1;
+            let total = 0;
+            for (const { name, startTime } of marks) {
+                const delta = lastStartTime !== -1 ? startTime - lastStartTime : 0;
+                total += delta;
+                md.value += `${name}\t${startTime}\t${delta}\t${total}\n`;
+                lastStartTime = startTime;
+            }
+            md.value += '```\n';
+        }
+    }
+    _addLoaderStats(md, stats) {
+        md.heading(2, 'Loader Stats');
+        md.heading(3, 'Load AMD-module');
+        md.table(['Module', 'Duration'], stats.amdLoad);
+        md.blank();
+        md.heading(3, 'Load commonjs-module');
+        md.table(['Module', 'Duration'], stats.nodeRequire);
+        md.blank();
+        md.heading(3, 'Invoke AMD-module factory');
+        md.table(['Module', 'Duration'], stats.amdInvoke);
+        md.blank();
+        md.heading(3, 'Invoke commonjs-module');
+        md.table(['Module', 'Duration'], stats.nodeEval);
+    }
+    _addCachedDataStats(md) {
+        const map = ( new Map());
+        map.set(63 , []);
+        map.set(60 , []);
+        map.set(61 , []);
+        map.set(62 , []);
+        if (typeof require.getStats === 'function') {
+            for (const stat of require.getStats()) {
+                if (( map.has(stat.type))) {
+                    map.get(stat.type).push(stat.detail);
+                }
+            }
+        }
+        const printLists = (arr) => {
+            if (arr) {
+                arr.sort();
+                for (const e of arr) {
+                    md.li(`${e}`);
+                }
+                md.blank();
+            }
+        };
+        md.heading(2, 'Node Cached Data Stats');
+        md.blank();
+        md.heading(3, 'cached data used');
+        printLists(map.get(60 ));
+        md.heading(3, 'cached data missed');
+        printLists(map.get(61 ));
+        md.heading(3, 'cached data rejected');
+        printLists(map.get(62 ));
+        md.heading(3, 'cached data created (lazy, might need refreshes)');
+        printLists(map.get(63 ));
+    }
+    _addResourceTimingStats(md) {
+        const stats = ( performance.getEntriesByType('resource').map(entry => {
+            return [entry.name, entry.duration];
+        }));
+        if (!stats.length) {
+            return;
+        }
+        md.heading(2, 'Resource Timing Stats');
+        md.table(['Name', 'Duration'], stats);
+    }
+};
+PerfModelContentProvider = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ILanguageService)),
+    ( __param(2, ICodeEditorService)),
+    ( __param(3, ILifecycleService)),
+    ( __param(4, ITimerService)),
+    ( __param(5, IExtensionService)),
+    ( __param(6, IProductService)),
+    ( __param(7, ITerminalService))
+], PerfModelContentProvider));
+class MarkdownBuilder {
+    constructor() {
+        this.value = '';
+    }
+    heading(level, value) {
+        this.value += `${'#'.repeat(level)} ${value}\n\n`;
+        return this;
+    }
+    blank() {
+        this.value += '\n';
+        return this;
+    }
+    li(value) {
+        this.value += `* ${value}\n`;
+        return this;
+    }
+    table(header, rows) {
+        this.value += LoaderStats.toMarkdownTable(header, rows);
+    }
+}
+export { PerfviewContrib, PerfviewInput };

package/vscode/src/vs/workbench/contrib/performance/browser/startupTimings.js

@@ -0,0 +1,114 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { isCodeEditor } from '../../../../editor/browser/editorBrowser.js';
+import { StartupKindToString, ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IUpdateService } from '../../../../platform/update/common/update.js';
+import { VIEWLET_ID } from '../../files/common/files.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IWorkspaceTrustManagementService } from '../../../../platform/workspace/common/workspaceTrust.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IProductService } from '../../../../platform/product/common/productService.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { IBrowserWorkbenchEnvironmentService } from '../../../services/environment/browser/environmentService.js';
+import { ITimerService } from '../../../services/timer/browser/timerService.js';
+import { posix } from '../../../../base/common/path.js';
+import { hash } from '../../../../base/common/hash.js';
+let StartupTimings = class StartupTimings {
+    constructor(_editorService, _paneCompositeService, _lifecycleService, _updateService, _workspaceTrustService) {
+        this._editorService = _editorService;
+        this._paneCompositeService = _paneCompositeService;
+        this._lifecycleService = _lifecycleService;
+        this._updateService = _updateService;
+        this._workspaceTrustService = _workspaceTrustService;
+    }
+    async _isStandardStartup() {
+        if (this._lifecycleService.startupKind !== 1 ) {
+            return StartupKindToString(this._lifecycleService.startupKind);
+        }
+        if (!this._workspaceTrustService.isWorkspaceTrusted()) {
+            return 'Workspace not trusted';
+        }
+        const activeViewlet = this._paneCompositeService.getActivePaneComposite(0 );
+        if (!activeViewlet || activeViewlet.getId() !== VIEWLET_ID) {
+            return 'Explorer viewlet not visible';
+        }
+        const visibleEditorPanes = this._editorService.visibleEditorPanes;
+        if (visibleEditorPanes.length !== 1) {
+            return `Expected text editor count : 1, Actual : ${visibleEditorPanes.length}`;
+        }
+        if (!isCodeEditor(visibleEditorPanes[0].getControl())) {
+            return 'Active editor is not a text editor';
+        }
+        const activePanel = this._paneCompositeService.getActivePaneComposite(1 );
+        if (activePanel) {
+            return `Current active panel : ${this._paneCompositeService.getPaneComposite(activePanel.getId(), 1 )?.name}`;
+        }
+        const isLatestVersion = await this._updateService.isLatestVersion();
+        if (isLatestVersion === false) {
+            return 'Not on latest version, updates available';
+        }
+        return undefined;
+    }
+};
+StartupTimings = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IPaneCompositePartService)),
+    ( __param(2, ILifecycleService)),
+    ( __param(3, IUpdateService)),
+    ( __param(4, IWorkspaceTrustManagementService))
+], StartupTimings));
+let BrowserStartupTimings = class BrowserStartupTimings extends StartupTimings {
+    constructor(editorService, paneCompositeService, lifecycleService, updateService, workspaceTrustService, timerService, logService, environmentService, telemetryService, productService) {
+        super(editorService, paneCompositeService, lifecycleService, updateService, workspaceTrustService);
+        this.timerService = timerService;
+        this.logService = logService;
+        this.environmentService = environmentService;
+        this.telemetryService = telemetryService;
+        this.productService = productService;
+        this.logPerfMarks();
+    }
+    async logPerfMarks() {
+        if (!this.environmentService.profDurationMarkers) {
+            return;
+        }
+        await this.timerService.whenReady();
+        const standardStartupError = await this._isStandardStartup();
+        const perfBaseline = await this.timerService.perfBaseline;
+        const [from, to] = this.environmentService.profDurationMarkers;
+        const content = `${this.timerService.getDuration(from, to)}\t${this.productService.nameShort}\t${(this.productService.commit || '').slice(0, 10) || '0000000000'}\t${this.telemetryService.sessionId}\t${standardStartupError === undefined ? 'standard_start' : 'NO_standard_start : ' + standardStartupError}\t${String(perfBaseline).padStart(4, '0')}ms\n`;
+        this.logService.info(`[prof-timers] ${content}`);
+    }
+};
+BrowserStartupTimings = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IPaneCompositePartService)),
+    ( __param(2, ILifecycleService)),
+    ( __param(3, IUpdateService)),
+    ( __param(4, IWorkspaceTrustManagementService)),
+    ( __param(5, ITimerService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IBrowserWorkbenchEnvironmentService)),
+    ( __param(8, ITelemetryService)),
+    ( __param(9, IProductService))
+], BrowserStartupTimings));
+let BrowserResourcePerformanceMarks = class BrowserResourcePerformanceMarks {
+    constructor(telemetryService) {
+        for (const item of performance.getEntriesByType('resource')) {
+            try {
+                const url = ( new URL(item.name));
+                const name = posix.basename(url.pathname);
+                telemetryService.publicLog2('startup.resource.perf', {
+                    hosthash: `H${( hash(url.host).toString(16))}`,
+                    name,
+                    duration: item.duration
+                });
+            }
+            catch {
+            }
+        }
+    }
+};
+BrowserResourcePerformanceMarks = ( __decorate([
+    ( __param(0, ITelemetryService))
+], BrowserResourcePerformanceMarks));
+export { BrowserResourcePerformanceMarks, BrowserStartupTimings, StartupTimings };