async getDiagnostics(launchService: ILaunchService): Promise<string> {
		const output: string[] = [];
		const info = await launchService.getMainProcessInfo();
		return listProcesses(info.mainPID).then(async rootProcess => {

			// Environment Info
			output.push('');
			output.push(this.formatEnvironment(info));

			// Process List
			output.push('');
			output.push(this.formatProcessList(info, rootProcess));

			// Workspace Stats
			if (info.windows.some(window => window.folderURIs && window.folderURIs.length > 0 && !window.remoteAuthority)) {
				output.push('');
				output.push('Workspace Stats: ');
				output.push(await this.formatWorkspaceMetadata(info));
			}

			try {
				const data = await launchService.getRemoteDiagnostics({ includeProcesses: true, includeWorkspaceMetadata: true });
				data.forEach(diagnostics => {
					if (isRemoteDiagnosticError(diagnostics)) {
						output.push(`\n${diagnostics.errorMessage}`);
					} else {
						output.push('\n\n');
						output.push(`Remote:           ${diagnostics.hostName}`);
						output.push(this.formatMachineInfo(diagnostics.machineInfo));

						if (diagnostics.processes) {
							output.push(this.formatProcessList(info, diagnostics.processes));
						}

						if (diagnostics.workspaceMetadata) {
							for (const folder of Object.keys(diagnostics.workspaceMetadata)) {
								const metadata = diagnostics.workspaceMetadata[folder];

								let countMessage = `${metadata.fileCount} files`;
								if (metadata.maxFilesReached) {
									countMessage = `more than ${countMessage}`;
								}

								output.push(`Folder (${folder}): ${countMessage}`);
								output.push(this.formatWorkspaceStats(metadata));
							}
						}
					}
				});
			} catch (e) {
				output.push('\n\n');
				output.push(`Fetching status information from remotes failed: ${e.message}`);
			}

			output.push('');
			output.push('');

			return output.join('\n');
		});
	}

	async getSystemInfo(launchService: ILaunchService): Promise<SystemInfo> {
		const info = await launchService.getMainProcessInfo();
		const { memory, vmHint, os, cpus } = getMachineInfo();
		const systemInfo: SystemInfo = {
			os,
			memory,
			cpus,
			vmHint,
			processArgs: `${info.mainArguments.join(' ')}`,
			gpuStatus: app.getGPUFeatureStatus(),
			screenReader: `${app.isAccessibilitySupportEnabled() ? 'yes' : 'no'}`,
			remoteData: (await launchService.getRemoteDiagnostics({ includeProcesses: false, includeWorkspaceMetadata: false })).filter((x): x is IRemoteDiagnosticInfo => !(x instanceof Error))
		};


		if (!isWindows) {
			systemInfo.load = `${osLib.loadavg().map(l => Math.round(l)).join(', ')}`;
		}

		return Promise.resolve(systemInfo);
	}

	async getPerformanceInfo(launchService: ILaunchService): Promise<PerformanceInfo> {
		const info = await launchService.getMainProcessInfo();
		return Promise.all<ProcessItem, string>([listProcesses(info.mainPID), this.formatWorkspaceMetadata(info)]).then(async result => {
			let [rootProcess, workspaceInfo] = result;
			let processInfo = this.formatProcessList(info, rootProcess);

			try {
				const remoteData = await launchService.getRemoteDiagnostics({ includeProcesses: true, includeWorkspaceMetadata: true });
				remoteData.forEach(diagnostics => {
					if (isRemoteDiagnosticError(diagnostics)) {
						processInfo += `\n${diagnostics.errorMessage}`;
						workspaceInfo += `\n${diagnostics.errorMessage}`;
					} else {
						processInfo += `\n\nRemote: ${diagnostics.hostName}`;
						if (diagnostics.processes) {
							processInfo += `\n${this.formatProcessList(info, diagnostics.processes)}`;
						}

						if (diagnostics.workspaceMetadata) {
							workspaceInfo += `\n|  Remote: ${diagnostics.hostName}`;
							for (const folder of Object.keys(diagnostics.workspaceMetadata)) {
								const metadata = diagnostics.workspaceMetadata[folder];

								let countMessage = `${metadata.fileCount} files`;
								if (metadata.maxFilesReached) {
									countMessage = `more than ${countMessage}`;
								}

								workspaceInfo += `|    Folder (${folder}): ${countMessage}`;
								workspaceInfo += this.formatWorkspaceStats(metadata);
							}
						}
					}
				});
			} catch (e) {
				processInfo += `\nFetching remote data failed: ${e}`;
				workspaceInfo += `\nFetching remote data failed: ${e}`;
			}

			return {
				processInfo,
				workspaceInfo
			};
		});
	}

export async function uploadLogs(
	launchService: ILaunchService,
	requestService: IRequestService,
	environmentService: IEnvironmentService
): Promise<any> {
	const endpoint = Endpoint.getFromProduct();
	if (!endpoint) {
		console.error(localize('invalidEndpoint', 'Invalid log uploader endpoint'));
		return;
	}

	const logsPath = await launchService.getLogsPath();

	if (await promptUserToConfirmLogUpload(logsPath, environmentService)) {
		console.log(localize('beginUploading', 'Uploading...'));
		const outZip = await zipLogs(logsPath);
		const result = await postLogs(endpoint, outZip, requestService);
		console.log(localize('didUploadLogs', 'Upload successful! Log file ID: {0}', result.blob_id));
	}
}