Merge from vscode bead496a613e475819f89f08e9e882b841bc1fe8 (#14883)

* Merge from vscode bead496a613e475819f89f08e9e882b841bc1fe8 * Bump distro * Upgrade GCC to 4.9 due to yarn install errors * Update build image * Fix bootstrap base url * Bump distro * Fix build errors * Update source map file * Disable checkbox for blocking migration issues (#15131) * disable checkbox for blocking issues * wip * disable checkbox fixes * fix strings * Remove duplicate tsec command * Default to off for tab color if settings not present * re-skip failing tests * Fix mocha error * Bump sqlite version & fix notebooks search view * Turn off esbuild warnings * Update esbuild log level * Fix overflowactionbar tests * Fix ts-ignore in dropdown tests * cleanup/fixes * Fix hygiene * Bundle in entire zone.js module * Remove extra constructor param * bump distro for web compile break * bump distro for web compile break v2 * Undo log level change * New distro * Fix integration test scripts * remove the "no yarn.lock changes" workflow * fix scripts v2 * Update unit test scripts * Ensure ads-kerberos2 updates in .vscodeignore * Try fix unit tests * Upload crash reports * remove nogpu * always upload crashes * Use bash script * Consolidate data/ext dir names * Create in tmp directory Co-authored-by: chlafreniere <hichise@gmail.com> Co-authored-by: Christopher Suh <chsuh@microsoft.com> Co-authored-by: chgagnon <chgagnon@microsoft.com>
2026-02-15 10:58:31 -05:00 · 2021-04-27 14:01:59 -07:00
parent 7e1c0076ba
commit 867a963882
1817 changed files with 81812 additions and 50843 deletions
--- a/src/vs/platform/userDataSync/common/extensionsStorageSync.ts
+++ b/src/vs/platform/userDataSync/common/extensionsStorageSync.ts
@@ -5,6 +5,7 @@

 import { Emitter, Event } from 'vs/base/common/event';
 import { Disposable } from 'vs/base/common/lifecycle';
+import { adoptToGalleryExtensionId } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { IStorageService, IStorageValueChangeEvent, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';

@@ -32,7 +33,7 @@ export class ExtensionsStorageSyncService extends Disposable implements IExtensi
 	declare readonly _serviceBrand: undefined;

 	private static toKey(extension: IExtensionIdWithVersion): string {
-		return `extensionKeys/${extension.id}@${extension.version}`;
+		return `extensionKeys/${adoptToGalleryExtensionId(extension.id)}@${extension.version}`;
 	}

 	private static fromKey(key: string): IExtensionIdWithVersion | undefined {
--- a/src/vs/platform/userDataSync/common/extensionsSync.ts
+++ b/src/vs/platform/userDataSync/common/extensionsSync.ts
@@ -11,7 +11,7 @@ import { Event } from 'vs/base/common/event';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { IExtensionManagementService, IExtensionGalleryService, IGlobalExtensionEnablementService, ILocalExtension } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { ExtensionType, IExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
-import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { areSameExtensions, getExtensionId, getGalleryExtensionId } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
 import { IFileService } from 'vs/platform/files/common/files';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { merge } from 'vs/platform/userDataSync/common/extensionsMerge';
@@ -25,8 +25,9 @@ import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storag
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { IIgnoredExtensionsManagementService } from 'vs/platform/userDataSync/common/ignoredExtensions';
 import { getErrorMessage } from 'vs/base/common/errors';
-import { forEach, IStringDictionary } from 'vs/base/common/collections';
+import { IStringDictionary } from 'vs/base/common/collections';
 import { IExtensionsStorageSyncService } from 'vs/platform/userDataSync/common/extensionsStorageSync';
+import { Promises } from 'vs/base/common/async';

 interface IExtensionResourceMergeResult extends IAcceptResult {
 	readonly added: ISyncExtension[];
@@ -73,6 +74,15 @@ async function parseAndMigrateExtensions(syncData: ISyncData, extensionManagemen
 	return extensions;
 }

+function getExtensionStorageState(publisher: string, name: string, storageService: IStorageService): IStringDictionary<any> {
+	const extensionStorageValue = storageService.get(getExtensionId(publisher, name) /* use the same id used in extension host */, StorageScope.GLOBAL) || '{}';
+	return JSON.parse(extensionStorageValue);
+}
+
+function storeExtensionStorageState(publisher: string, name: string, extensionState: IStringDictionary<any>, storageService: IStorageService): void {
+	storageService.store(getExtensionId(publisher, name) /* use the same id used in extension host */, JSON.stringify(extensionState), StorageScope.GLOBAL, StorageTarget.MACHINE);
+}
+
 export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUserDataSynchroniser {

 	private static readonly EXTENSIONS_DATA_URI = URI.from({ scheme: USER_DATA_SYNC_SCHEME, authority: 'extensions', path: `/extensions.json` });
@@ -99,7 +109,7 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse
 		@IUserDataSyncBackupStoreService userDataSyncBackupStoreService: IUserDataSyncBackupStoreService,
 		@IExtensionManagementService private readonly extensionManagementService: IExtensionManagementService,
 		@IGlobalExtensionEnablementService private readonly extensionEnablementService: IGlobalExtensionEnablementService,
-		@IIgnoredExtensionsManagementService private readonly extensionSyncManagementService: IIgnoredExtensionsManagementService,
+		@IIgnoredExtensionsManagementService private readonly ignoredExtensionsManagementService: IIgnoredExtensionsManagementService,
 		@IUserDataSyncLogService logService: IUserDataSyncLogService,
 		@IExtensionGalleryService private readonly extensionGalleryService: IExtensionGalleryService,
 		@IConfigurationService configurationService: IConfigurationService,
@@ -125,7 +135,7 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse

 		const installedExtensions = await this.extensionManagementService.getInstalled();
 		const localExtensions = this.getLocalExtensions(installedExtensions);
-		const ignoredExtensions = this.extensionSyncManagementService.getIgnoredExtensions(installedExtensions);
+		const ignoredExtensions = this.ignoredExtensionsManagementService.getIgnoredExtensions(installedExtensions);

 		if (remoteExtensions) {
 			this.logService.trace(`${this.syncResourceLogLabel}: Merging remote extensions with local extensions...`);
@@ -209,7 +219,7 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse

 	private async acceptLocal(resourcePreview: IExtensionResourcePreview): Promise<IExtensionResourceMergeResult> {
 		const installedExtensions = await this.extensionManagementService.getInstalled();
-		const ignoredExtensions = this.extensionSyncManagementService.getIgnoredExtensions(installedExtensions);
+		const ignoredExtensions = this.ignoredExtensionsManagementService.getIgnoredExtensions(installedExtensions);
 		const mergeResult = merge(resourcePreview.localExtensions, null, null, resourcePreview.skippedExtensions, ignoredExtensions);
 		const { added, removed, updated, remote } = mergeResult;
 		return {
@@ -225,7 +235,7 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse

 	private async acceptRemote(resourcePreview: IExtensionResourcePreview): Promise<IExtensionResourceMergeResult> {
 		const installedExtensions = await this.extensionManagementService.getInstalled();
-		const ignoredExtensions = this.extensionSyncManagementService.getIgnoredExtensions(installedExtensions);
+		const ignoredExtensions = this.ignoredExtensionsManagementService.getIgnoredExtensions(installedExtensions);
 		const remoteExtensions = resourcePreview.remoteContent ? JSON.parse(resourcePreview.remoteContent) : null;
 		if (remoteExtensions !== null) {
 			const mergeResult = merge(resourcePreview.localExtensions, remoteExtensions, resourcePreview.localExtensions, [], ignoredExtensions);
@@ -285,7 +295,7 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse
 	async resolveContent(uri: URI): Promise<string | null> {
 		if (this.extUri.isEqual(uri, ExtensionsSynchroniser.EXTENSIONS_DATA_URI)) {
 			const installedExtensions = await this.extensionManagementService.getInstalled();
-			const ignoredExtensions = this.extensionSyncManagementService.getIgnoredExtensions(installedExtensions);
+			const ignoredExtensions = this.ignoredExtensionsManagementService.getIgnoredExtensions(installedExtensions);
 			const localExtensions = this.getLocalExtensions(installedExtensions).filter(e => !ignoredExtensions.some(id => areSameExtensions({ id }, e.identifier)));
 			return this.format(localExtensions);
 		}
@@ -348,7 +358,7 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse

 		if (removed.length) {
 			const extensionsToRemove = installedExtensions.filter(({ identifier, isBuiltin }) => !isBuiltin && removed.some(r => areSameExtensions(identifier, r)));
-			await Promise.all(extensionsToRemove.map(async extensionToRemove => {
+			await Promises.settled(extensionsToRemove.map(async extensionToRemove => {
 				this.logService.trace(`${this.syncResourceLogLabel}: Uninstalling local extension...`, extensionToRemove.identifier.id);
 				await this.extensionManagementService.uninstall(extensionToRemove, { donotIncludePack: true, donotCheckDependents: true });
 				this.logService.info(`${this.syncResourceLogLabel}: Uninstalled local extension.`, extensionToRemove.identifier.id);
@@ -357,13 +367,13 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse
 		}

 		if (added.length || updated.length) {
-			await Promise.all([...added, ...updated].map(async e => {
+			await Promises.settled([...added, ...updated].map(async e => {
 				const installedExtension = installedExtensions.find(installed => areSameExtensions(installed.identifier, e.identifier));

 				// Builtin Extension Sync: Enablement & State
 				if (installedExtension && installedExtension.isBuiltin) {
 					if (e.state && installedExtension.manifest.version === e.version) {
-						this.updateExtensionState(e.state, e.identifier.id, installedExtension.manifest.version);
+						this.updateExtensionState(e.state, installedExtension.manifest.publisher, installedExtension.manifest.name, installedExtension.manifest.version);
 					}
 					if (e.disabled) {
 						this.logService.trace(`${this.syncResourceLogLabel}: Disabling extension...`, e.identifier.id);
@@ -382,14 +392,16 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse
 				const extension = await this.extensionGalleryService.getCompatibleExtension(e.identifier);

 				/* Update extension state only if
-				*		extension is installed and version is same as synced version or
-				 *		extension is not installed and installable
+				 *	extension is installed and version is same as synced version or
+				 *	extension is not installed and installable
 				 */
 				if (e.state &&
 					(installedExtension ? installedExtension.manifest.version === e.version /* Installed and has same version */
 						: !!extension /* Installable */)
 				) {
-					this.updateExtensionState(e.state, e.identifier.id, installedExtension?.manifest.version);
+					const publisher = installedExtension ? installedExtension.manifest.publisher : extension!.publisher;
+					const name = installedExtension ? installedExtension.manifest.name : extension!.name;
+					this.updateExtensionState(e.state, publisher, name, installedExtension?.manifest.version);
 				}

 				if (extension) {
@@ -436,15 +448,15 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse
 		return newSkippedExtensions;
 	}

-	private updateExtensionState(state: IStringDictionary<any>, id: string, version?: string): void {
-		const extensionState = JSON.parse(this.storageService.get(id, StorageScope.GLOBAL) || '{}');
-		const keys = version ? this.extensionsStorageSyncService.getKeysForSync({ id, version }) : undefined;
+	private updateExtensionState(state: IStringDictionary<any>, publisher: string, name: string, version: string | undefined): void {
+		const extensionState = getExtensionStorageState(publisher, name, this.storageService);
+		const keys = version ? this.extensionsStorageSyncService.getKeysForSync({ id: getGalleryExtensionId(publisher, name), version }) : undefined;
 		if (keys) {
-			keys.forEach(key => extensionState[key] = state[key]);
+			keys.forEach(key => { extensionState[key] = state[key]; });
 		} else {
-			forEach(state, ({ key, value }) => extensionState[key] = value);
+			Object.keys(state).forEach(key => extensionState[key] = state[key]);
 		}
-		this.storageService.store(id, JSON.stringify(extensionState), StorageScope.GLOBAL, StorageTarget.MACHINE);
+		storeExtensionStorageState(publisher, name, extensionState, this.storageService);
 	}

 	private parseExtensions(syncData: ISyncData): ISyncExtension[] {
@@ -465,8 +477,7 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse
 				try {
 					const keys = this.extensionsStorageSyncService.getKeysForSync({ id: identifier.id, version: manifest.version });
 					if (keys) {
-						const extensionStorageValue = this.storageService.get(identifier.id, StorageScope.GLOBAL) || '{}';
-						const extensionStorageState = JSON.parse(extensionStorageValue);
+						const extensionStorageState = getExtensionStorageState(manifest.publisher, manifest.name, this.storageService);
 						syncExntesion.state = Object.keys(extensionStorageState).reduce((state: IStringDictionary<any>, key) => {
 							if (keys.includes(key)) {
 								state[key] = extensionStorageState[key];
@@ -490,6 +501,7 @@ export class ExtensionsInitializer extends AbstractInitializer {
 		@IExtensionGalleryService private readonly galleryService: IExtensionGalleryService,
 		@IGlobalExtensionEnablementService private readonly extensionEnablementService: IGlobalExtensionEnablementService,
 		@IStorageService private readonly storageService: IStorageService,
+		@IIgnoredExtensionsManagementService private readonly ignoredExtensionsManagementService: IIgnoredExtensionsManagementService,
 		@IFileService fileService: IFileService,
 		@IEnvironmentService environmentService: IEnvironmentService,
 		@IUserDataSyncLogService logService: IUserDataSyncLogService,
@@ -511,12 +523,18 @@ export class ExtensionsInitializer extends AbstractInitializer {
 		const newlyEnabledExtensions: ILocalExtension[] = [];
 		const installedExtensions = await this.extensionManagementService.getInstalled();
 		const newExtensionsToSync = new Map<string, ISyncExtension>();
-		const installedExtensionsToSync: ISyncExtension[] = [];
+		const installedExtensionsToSync: { syncExtension: ISyncExtension, installedExtension: ILocalExtension }[] = [];
 		const toInstall: { names: string[], uuids: string[] } = { names: [], uuids: [] };
 		const toDisable: IExtensionIdentifier[] = [];
 		for (const extension of remoteExtensions) {
-			if (installedExtensions.some(i => areSameExtensions(i.identifier, extension.identifier))) {
-				installedExtensionsToSync.push(extension);
+			if (this.ignoredExtensionsManagementService.hasToNeverSyncExtension(extension.identifier.id)) {
+				// Skip extension ignored to sync
+				continue;
+			}
+
+			const installedExtension = installedExtensions.find(i => areSameExtensions(i.identifier, extension.identifier));
+			if (installedExtension) {
+				installedExtensionsToSync.push({ syncExtension: extension, installedExtension });
 				if (extension.disabled) {
 					toDisable.push(extension.identifier);
 				}
@@ -528,17 +546,39 @@ export class ExtensionsInitializer extends AbstractInitializer {
 					} else {
 						toInstall.names.push(extension.identifier.id);
 					}
+					if (extension.disabled) {
+						toDisable.push(extension.identifier);
+					}
 				}
 			}
 		}

+		// 1. Initialise already installed extensions state
+		for (const { syncExtension, installedExtension } of installedExtensionsToSync) {
+			if (syncExtension.state) {
+				const extensionState = getExtensionStorageState(installedExtension.manifest.publisher, installedExtension.manifest.name, this.storageService);
+				Object.keys(syncExtension.state).forEach(key => extensionState[key] = syncExtension.state![key]);
+				storeExtensionStorageState(installedExtension.manifest.publisher, installedExtension.manifest.name, extensionState, this.storageService);
+			}
+		}
+
+		// 2. Initialise extensions enablement
+		if (toDisable.length) {
+			for (const identifier of toDisable) {
+				this.logService.trace(`Disabling extension...`, identifier.id);
+				await this.extensionEnablementService.disableExtension(identifier);
+				this.logService.info(`Disabling extension`, identifier.id);
+			}
+		}
+
+		// 3. Install extensions
 		if (toInstall.names.length || toInstall.uuids.length) {
 			const galleryExtensions = (await this.galleryService.query({ ids: toInstall.uuids, names: toInstall.names, pageSize: toInstall.uuids.length + toInstall.names.length }, CancellationToken.None)).firstPage;
 			for (const galleryExtension of galleryExtensions) {
 				try {
 					const extensionToSync = newExtensionsToSync.get(galleryExtension.identifier.id.toLowerCase())!;
 					if (extensionToSync.state) {
-						this.storageService.store(extensionToSync.identifier.id, JSON.stringify(extensionToSync.state), StorageScope.GLOBAL, StorageTarget.MACHINE);
+						storeExtensionStorageState(galleryExtension.publisher, galleryExtension.name, extensionToSync.state, this.storageService);
 					}
 					this.logService.trace(`Installing extension...`, galleryExtension.identifier.id);
 					const local = await this.extensionManagementService.installFromGallery(galleryExtension, { isMachineScoped: false } /* pass options to prevent install and sync dialog in web */);
@@ -552,22 +592,6 @@ export class ExtensionsInitializer extends AbstractInitializer {
 			}
 		}

-		if (toDisable.length) {
-			for (const identifier of toDisable) {
-				this.logService.trace(`Enabling extension...`, identifier.id);
-				await this.extensionEnablementService.disableExtension(identifier);
-				this.logService.info(`Enabled extension`, identifier.id);
-			}
-		}
-
-		for (const extensionToSync of installedExtensionsToSync) {
-			if (extensionToSync.state) {
-				const extensionState = JSON.parse(this.storageService.get(extensionToSync.identifier.id, StorageScope.GLOBAL) || '{}');
-				forEach(extensionToSync.state, ({ key, value }) => extensionState[key] = value);
-				this.storageService.store(extensionToSync.identifier.id, JSON.stringify(extensionState), StorageScope.GLOBAL, StorageTarget.MACHINE);
-			}
-		}
-
 		return newlyEnabledExtensions;
 	}

--- a/src/vs/platform/userDataSync/common/userDataSync.ts
+++ b/src/vs/platform/userDataSync/common/userDataSync.ts
@@ -31,9 +31,10 @@ export function getDisallowedIgnoredSettings(): string[] {

 export function getDefaultIgnoredSettings(): string[] {
 	const allSettings = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration).getConfigurationProperties();
+	const ignoreSyncSettings = Object.keys(allSettings).filter(setting => !!allSettings[setting].ignoreSync);
 	const machineSettings = Object.keys(allSettings).filter(setting => allSettings[setting].scope === ConfigurationScope.MACHINE || allSettings[setting].scope === ConfigurationScope.MACHINE_OVERRIDABLE);
 	const disallowedSettings = getDisallowedIgnoredSettings();
-	return distinct([CONFIGURATION_SYNC_STORE_KEY, ...machineSettings, ...disallowedSettings]);
+	return distinct([CONFIGURATION_SYNC_STORE_KEY, ...ignoreSyncSettings, ...machineSettings, ...disallowedSettings]);
 }

 export function registerConfiguration(): IDisposable {
@@ -52,10 +53,6 @@ export function registerConfiguration(): IDisposable {
 				scope: ConfigurationScope.APPLICATION,
 				tags: ['sync', 'usesOnlineServices']
 			},
-			'sync.keybindingsPerPlatform': {
-				type: 'boolean',
-				deprecationMessage: localize('sync.keybindingsPerPlatform.deprecated', "Deprecated, use settingsSync.keybindingsPerPlatform instead"),
-			},
 			'settingsSync.ignoredExtensions': {
 				'type': 'array',
 				markdownDescription: localize('settingsSync.ignoredExtensions', "List of extensions to be ignored while synchronizing. The identifier of an extension is always `${publisher}.${name}`. For example: `vscode.csharp`."),
@@ -70,10 +67,6 @@ export function registerConfiguration(): IDisposable {
 				disallowSyncIgnore: true,
 				tags: ['sync', 'usesOnlineServices']
 			},
-			'sync.ignoredExtensions': {
-				'type': 'array',
-				deprecationMessage: localize('sync.ignoredExtensions.deprecated', "Deprecated, use settingsSync.ignoredExtensions instead"),
-			},
 			'settingsSync.ignoredSettings': {
 				'type': 'array',
 				description: localize('settingsSync.ignoredSettings', "Configure settings to be ignored while synchronizing."),
@@ -84,10 +77,6 @@ export function registerConfiguration(): IDisposable {
 				uniqueItems: true,
 				disallowSyncIgnore: true,
 				tags: ['sync', 'usesOnlineServices']
-			},
-			'sync.ignoredSettings': {
-				'type': 'array',
-				deprecationMessage: localize('sync.ignoredSettings.deprecated', "Deprecated, use settingsSync.ignoredSettings instead"),
 			}
 		}
 	});
--- a/src/vs/platform/userDataSync/common/userDataSyncBackupStoreService.ts
+++ b/src/vs/platform/userDataSync/common/userDataSyncBackupStoreService.ts
@@ -11,6 +11,7 @@ import { IFileService, IFileStat } from 'vs/platform/files/common/files';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { toLocalISOString } from 'vs/base/common/date';
 import { VSBuffer } from 'vs/base/common/buffer';
+import { Promises } from 'vs/base/common/async';

 export class UserDataSyncBackupStoreService extends Disposable implements IUserDataSyncBackupStoreService {

@@ -86,9 +87,9 @@ export class UserDataSyncBackupStoreService extends Disposable implements IUserD
 				if (remaining < 10) {
 					toDelete = toDelete.slice(10 - remaining);
 				}
-				await Promise.all(toDelete.map(stat => {
+				await Promises.settled(toDelete.map(async stat => {
 					this.logService.info('Deleting from backup', stat.resource.path);
-					this.fileService.del(stat.resource);
+					await this.fileService.del(stat.resource);
 				}));
 			}
 		} catch (e) {
--- a/src/vs/platform/userDataSync/common/userDataSyncService.ts
+++ b/src/vs/platform/userDataSync/common/userDataSyncService.ts
@@ -445,131 +445,171 @@ class ManualSyncTask extends Disposable implements IManualSyncTask {
 	}

 	async preview(): Promise<[SyncResource, ISyncResourcePreview][]> {
-		if (this.isDisposed) {
-			throw new Error('Disposed');
+		try {
+			if (this.isDisposed) {
+				throw new Error('Disposed');
+			}
+			if (!this.previewsPromise) {
+				this.previewsPromise = createCancelablePromise(token => this.getPreviews(token));
+			}
+			if (!this.previews) {
+				this.previews = await this.previewsPromise;
+			}
+			return this.previews;
+		} catch (error) {
+			this.logService.error(error);
+			throw error;
 		}
-		if (!this.previewsPromise) {
-			this.previewsPromise = createCancelablePromise(token => this.getPreviews(token));
-		}
-		if (!this.previews) {
-			this.previews = await this.previewsPromise;
-		}
-		return this.previews;
 	}

 	async accept(resource: URI, content?: string | null): Promise<[SyncResource, ISyncResourcePreview][]> {
-		return this.performAction(resource, sychronizer => sychronizer.accept(resource, content));
+		try {
+			return await this.performAction(resource, sychronizer => sychronizer.accept(resource, content));
+		} catch (error) {
+			this.logService.error(error);
+			throw error;
+		}
 	}

 	async merge(resource?: URI): Promise<[SyncResource, ISyncResourcePreview][]> {
-		if (resource) {
-			return this.performAction(resource, sychronizer => sychronizer.merge(resource));
-		} else {
-			return this.mergeAll();
+		try {
+			if (resource) {
+				return await this.performAction(resource, sychronizer => sychronizer.merge(resource));
+			} else {
+				return await this.mergeAll();
+			}
+		} catch (error) {
+			this.logService.error(error);
+			throw error;
 		}
 	}

 	async discard(resource: URI): Promise<[SyncResource, ISyncResourcePreview][]> {
-		return this.performAction(resource, sychronizer => sychronizer.discard(resource));
+		try {
+			return await this.performAction(resource, sychronizer => sychronizer.discard(resource));
+		} catch (error) {
+			this.logService.error(error);
+			throw error;
+		}
 	}

 	async discardConflicts(): Promise<[SyncResource, ISyncResourcePreview][]> {
-		if (!this.previews) {
-			throw new Error('Missing preview. Create preview and try again.');
-		}
-		if (this.synchronizingResources.length) {
-			throw new Error('Cannot discard while synchronizing resources');
-		}
+		try {
+			if (!this.previews) {
+				throw new Error('Missing preview. Create preview and try again.');
+			}
+			if (this.synchronizingResources.length) {
+				throw new Error('Cannot discard while synchronizing resources');
+			}

-		const conflictResources: URI[] = [];
-		for (const [, syncResourcePreview] of this.previews) {
-			for (const resourcePreview of syncResourcePreview.resourcePreviews) {
-				if (resourcePreview.mergeState === MergeState.Conflict) {
-					conflictResources.push(resourcePreview.previewResource);
+			const conflictResources: URI[] = [];
+			for (const [, syncResourcePreview] of this.previews) {
+				for (const resourcePreview of syncResourcePreview.resourcePreviews) {
+					if (resourcePreview.mergeState === MergeState.Conflict) {
+						conflictResources.push(resourcePreview.previewResource);
+					}
 				}
 			}
-		}

-		for (const resource of conflictResources) {
-			await this.discard(resource);
+			for (const resource of conflictResources) {
+				await this.discard(resource);
+			}
+			return this.previews;
+		} catch (error) {
+			this.logService.error(error);
+			throw error;
 		}
-		return this.previews;
 	}

 	async apply(): Promise<[SyncResource, ISyncResourcePreview][]> {
-		if (!this.previews) {
-			throw new Error('You need to create preview before applying');
-		}
-		if (this.synchronizingResources.length) {
-			throw new Error('Cannot pull while synchronizing resources');
-		}
-		const previews: [SyncResource, ISyncResourcePreview][] = [];
-		for (const [syncResource, preview] of this.previews) {
-			this.synchronizingResources.push([syncResource, preview.resourcePreviews.map(r => r.localResource)]);
-			this._onSynchronizeResources.fire(this.synchronizingResources);
+		try {
+			if (!this.previews) {
+				throw new Error('You need to create preview before applying');
+			}
+			if (this.synchronizingResources.length) {
+				throw new Error('Cannot pull while synchronizing resources');
+			}
+			const previews: [SyncResource, ISyncResourcePreview][] = [];
+			for (const [syncResource, preview] of this.previews) {
+				this.synchronizingResources.push([syncResource, preview.resourcePreviews.map(r => r.localResource)]);
+				this._onSynchronizeResources.fire(this.synchronizingResources);

-			const synchroniser = this.synchronisers.find(s => s.resource === syncResource)!;
+				const synchroniser = this.synchronisers.find(s => s.resource === syncResource)!;

-			/* merge those which are not yet merged */
-			for (const resourcePreview of preview.resourcePreviews) {
-				if ((resourcePreview.localChange !== Change.None || resourcePreview.remoteChange !== Change.None) && resourcePreview.mergeState === MergeState.Preview) {
-					await synchroniser.merge(resourcePreview.previewResource);
+				/* merge those which are not yet merged */
+				for (const resourcePreview of preview.resourcePreviews) {
+					if ((resourcePreview.localChange !== Change.None || resourcePreview.remoteChange !== Change.None) && resourcePreview.mergeState === MergeState.Preview) {
+						await synchroniser.merge(resourcePreview.previewResource);
+					}
 				}
-			}

-			/* apply */
-			const newPreview = await synchroniser.apply(false, this.syncHeaders);
-			if (newPreview) {
-				previews.push(this.toSyncResourcePreview(synchroniser.resource, newPreview));
-			}
+				/* apply */
+				const newPreview = await synchroniser.apply(false, this.syncHeaders);
+				if (newPreview) {
+					previews.push(this.toSyncResourcePreview(synchroniser.resource, newPreview));
+				}

-			this.synchronizingResources.splice(this.synchronizingResources.findIndex(s => s[0] === syncResource), 1);
-			this._onSynchronizeResources.fire(this.synchronizingResources);
+				this.synchronizingResources.splice(this.synchronizingResources.findIndex(s => s[0] === syncResource), 1);
+				this._onSynchronizeResources.fire(this.synchronizingResources);
+			}
+			this.previews = previews;
+			return this.previews;
+		} catch (error) {
+			this.logService.error(error);
+			throw error;
 		}
-		this.previews = previews;
-		return this.previews;
 	}

 	async pull(): Promise<void> {
-		if (!this.previews) {
-			throw new Error('You need to create preview before applying');
-		}
-		if (this.synchronizingResources.length) {
-			throw new Error('Cannot pull while synchronizing resources');
-		}
-		for (const [syncResource, preview] of this.previews) {
-			this.synchronizingResources.push([syncResource, preview.resourcePreviews.map(r => r.localResource)]);
-			this._onSynchronizeResources.fire(this.synchronizingResources);
-			const synchroniser = this.synchronisers.find(s => s.resource === syncResource)!;
-			for (const resourcePreview of preview.resourcePreviews) {
-				await synchroniser.accept(resourcePreview.remoteResource);
+		try {
+			if (!this.previews) {
+				throw new Error('You need to create preview before applying');
 			}
-			await synchroniser.apply(true, this.syncHeaders);
-			this.synchronizingResources.splice(this.synchronizingResources.findIndex(s => s[0] === syncResource), 1);
-			this._onSynchronizeResources.fire(this.synchronizingResources);
+			if (this.synchronizingResources.length) {
+				throw new Error('Cannot pull while synchronizing resources');
+			}
+			for (const [syncResource, preview] of this.previews) {
+				this.synchronizingResources.push([syncResource, preview.resourcePreviews.map(r => r.localResource)]);
+				this._onSynchronizeResources.fire(this.synchronizingResources);
+				const synchroniser = this.synchronisers.find(s => s.resource === syncResource)!;
+				for (const resourcePreview of preview.resourcePreviews) {
+					await synchroniser.accept(resourcePreview.remoteResource);
+				}
+				await synchroniser.apply(true, this.syncHeaders);
+				this.synchronizingResources.splice(this.synchronizingResources.findIndex(s => s[0] === syncResource), 1);
+				this._onSynchronizeResources.fire(this.synchronizingResources);
+			}
+			this.previews = [];
+		} catch (error) {
+			this.logService.error(error);
+			throw error;
 		}
-		this.previews = [];
 	}

 	async push(): Promise<void> {
-		if (!this.previews) {
-			throw new Error('You need to create preview before applying');
-		}
-		if (this.synchronizingResources.length) {
-			throw new Error('Cannot pull while synchronizing resources');
-		}
-		for (const [syncResource, preview] of this.previews) {
-			this.synchronizingResources.push([syncResource, preview.resourcePreviews.map(r => r.localResource)]);
-			this._onSynchronizeResources.fire(this.synchronizingResources);
-			const synchroniser = this.synchronisers.find(s => s.resource === syncResource)!;
-			for (const resourcePreview of preview.resourcePreviews) {
-				await synchroniser.accept(resourcePreview.localResource);
+		try {
+			if (!this.previews) {
+				throw new Error('You need to create preview before applying');
 			}
-			await synchroniser.apply(true, this.syncHeaders);
-			this.synchronizingResources.splice(this.synchronizingResources.findIndex(s => s[0] === syncResource), 1);
-			this._onSynchronizeResources.fire(this.synchronizingResources);
+			if (this.synchronizingResources.length) {
+				throw new Error('Cannot pull while synchronizing resources');
+			}
+			for (const [syncResource, preview] of this.previews) {
+				this.synchronizingResources.push([syncResource, preview.resourcePreviews.map(r => r.localResource)]);
+				this._onSynchronizeResources.fire(this.synchronizingResources);
+				const synchroniser = this.synchronisers.find(s => s.resource === syncResource)!;
+				for (const resourcePreview of preview.resourcePreviews) {
+					await synchroniser.accept(resourcePreview.localResource);
+				}
+				await synchroniser.apply(true, this.syncHeaders);
+				this.synchronizingResources.splice(this.synchronizingResources.findIndex(s => s[0] === syncResource), 1);
+				this._onSynchronizeResources.fire(this.synchronizingResources);
+			}
+			this.previews = [];
+		} catch (error) {
+			this.logService.error(error);
+			throw error;
 		}
-		this.previews = [];
 	}

 	async stop(): Promise<void> {
--- a/src/vs/platform/userDataSync/common/userDataSyncStoreService.ts
+++ b/src/vs/platform/userDataSync/common/userDataSyncStoreService.ts
@@ -3,7 +3,7 @@
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

-import { Disposable, } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable, } from 'vs/base/common/lifecycle';
 import { IUserData, IUserDataSyncStoreService, UserDataSyncErrorCode, IUserDataSyncStore, ServerResource, UserDataSyncStoreError, IUserDataSyncLogService, IUserDataManifest, IResourceRefHandle, HEADER_OPERATION_ID, HEADER_EXECUTION_ID, CONFIGURATION_SYNC_STORE_KEY, IAuthenticationProvider, IUserDataSyncStoreManagementService, UserDataSyncStoreType, IUserDataSyncStoreClient } from 'vs/platform/userDataSync/common/userDataSync';
 import { IRequestService, asText, isSuccess as isSuccessContext, asJson } from 'vs/platform/request/common/request';
 import { joinPath, relativePath } from 'vs/base/common/resources';
@@ -180,6 +180,12 @@ export class UserDataSyncStoreClient extends Disposable implements IUserDataSync
 		/* A requests session that limits requests per sessions */
 		this.session = new RequestsSession(REQUEST_SESSION_LIMIT, REQUEST_SESSION_INTERVAL, this.requestService, this.logService);
 		this.initDonotMakeRequestsUntil();
+		this._register(toDisposable(() => {
+			if (this.resetDonotMakeRequestsUntilPromise) {
+				this.resetDonotMakeRequestsUntilPromise.cancel();
+				this.resetDonotMakeRequestsUntilPromise = undefined;
+			}
+		}));
 	}

 	setAuthToken(token: string, type: string): void {
@@ -210,6 +216,7 @@ export class UserDataSyncStoreClient extends Disposable implements IUserDataSync
 			if (this._donotMakeRequestsUntil) {
 				this.storageService.store(DONOT_MAKE_REQUESTS_UNTIL_KEY, this._donotMakeRequestsUntil.getTime(), StorageScope.GLOBAL, StorageTarget.MACHINE);
 				this.resetDonotMakeRequestsUntilPromise = createCancelablePromise(token => timeout(this._donotMakeRequestsUntil!.getTime() - Date.now(), token).then(() => this.setDonotMakeRequestsUntil(undefined)));
+				this.resetDonotMakeRequestsUntilPromise.then(null, e => null /* ignore error */);
 			} else {
 				this.storageService.remove(DONOT_MAKE_REQUESTS_UNTIL_KEY, StorageScope.GLOBAL);
 			}
--- a/src/vs/platform/userDataSync/test/common/synchronizer.test.ts
+++ b/src/vs/platform/userDataSync/test/common/synchronizer.test.ts
@@ -181,7 +181,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	teardown(() => disposableStore.clear());

 	test('status is syncing', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));

 		const actual: SyncStatus[] = [];
 		disposableStore.add(testObject.onDidChangeStatus(status => actual.push(status)));
@@ -198,7 +198,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('status is set correctly when sync is finished', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncBarrier.open();

 		const actual: SyncStatus[] = [];
@@ -210,7 +210,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('status is set correctly when sync has errors', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasError: true, hasConflicts: false };
 		testObject.syncBarrier.open();

@@ -227,7 +227,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('status is set to hasConflicts when asked to sync if there are conflicts', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -238,7 +238,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('sync should not run if syncing already', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		const promise = Event.toPromise(testObject.onDoSyncCall.event);

 		testObject.sync(await client.manifest());
@@ -255,7 +255,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('sync should not run if disabled', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		client.instantiationService.get(IUserDataSyncResourceEnablementService).setResourceEnablement(testObject.resource, false);

 		const actual: SyncStatus[] = [];
@@ -268,7 +268,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('sync should not run if there are conflicts', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -282,7 +282,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('accept preview during conflicts', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -300,7 +300,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('accept remote during conflicts', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
 		const fileService = client.instantiationService.get(IFileService);
@@ -323,7 +323,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('accept local during conflicts', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
 		const fileService = client.instantiationService.get(IFileService);
@@ -345,7 +345,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('accept new content during conflicts', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
 		const fileService = client.instantiationService.get(IFileService);
@@ -368,7 +368,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('accept delete during conflicts', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
 		const fileService = client.instantiationService.get(IFileService);
@@ -390,7 +390,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('accept deleted local during conflicts', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
 		const fileService = client.instantiationService.get(IFileService);
@@ -411,7 +411,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('accept deleted remote during conflicts', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncBarrier.open();
 		const fileService = client.instantiationService.get(IFileService);
 		await fileService.writeFile(testObject.localResource, VSBuffer.fromString('some content'));
@@ -431,7 +431,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('request latest data on precondition failure', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		// Sync once
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -458,7 +458,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('no requests are made to server when local change is triggered', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());

@@ -471,7 +471,7 @@ suite('TestSynchronizer - Auto Sync', () => {
 	});

 	test('status is reset when getting latest remote data fails', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.failWhenGettingLatestRemoteUserData = true;

 		try {
@@ -502,7 +502,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	teardown(() => disposableStore.clear());

 	test('preview', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -514,7 +514,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preview -> merge', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -528,7 +528,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preview -> accept', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -542,7 +542,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preview -> merge -> accept', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -557,7 +557,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preview -> merge -> apply', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -577,7 +577,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preview -> accept -> apply', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -597,7 +597,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preview -> merge -> accept -> apply', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -617,7 +617,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preview -> accept', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -630,7 +630,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preview -> accept -> apply', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -650,7 +650,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preivew -> merge -> discard', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -665,7 +665,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preivew -> merge -> discard -> accept', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -681,7 +681,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preivew -> accept -> discard', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -696,7 +696,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preivew -> accept -> discard -> accept', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -712,7 +712,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preivew -> accept -> discard -> merge', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -728,7 +728,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preivew -> merge -> accept -> discard', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -744,7 +744,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preivew -> merge -> discard -> accept -> apply', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -764,7 +764,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preivew -> accept -> discard -> accept -> apply', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -785,7 +785,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('preivew -> accept -> discard -> merge -> apply', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -808,7 +808,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preview', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -820,7 +820,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preview -> merge', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -834,7 +834,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preview -> merge -> discard', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -849,7 +849,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preview -> accept', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -864,7 +864,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preview -> merge -> accept -> apply', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -887,7 +887,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preview -> accept', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -901,7 +901,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preview -> accept -> apply', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -923,7 +923,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preivew -> merge -> discard', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -938,7 +938,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preivew -> merge -> discard -> accept', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -954,7 +954,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preivew -> accept -> discard', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -969,7 +969,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preivew -> accept -> discard -> accept', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -985,7 +985,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preivew -> accept -> discard -> merge', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -1001,7 +1001,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preivew -> merge -> discard -> merge', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: true, hasError: false };
 		testObject.syncBarrier.open();

@@ -1017,7 +1017,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preivew -> merge -> accept -> discard', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();

@@ -1033,7 +1033,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preivew -> merge -> discard -> accept -> apply', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
@@ -1053,7 +1053,7 @@ suite('TestSynchronizer - Manual Sync', () => {
 	});

 	test('conflicts: preivew -> accept -> discard -> accept -> apply', async () => {
-		const testObject: TestSynchroniser = client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings);
+		const testObject: TestSynchroniser = disposableStore.add(client.instantiationService.createInstance(TestSynchroniser, SyncResource.Settings));
 		testObject.syncResult = { hasConflicts: false, hasError: false };
 		testObject.syncBarrier.open();
 		await testObject.sync(await client.manifest());
--- a/src/vs/platform/userDataSync/test/common/userDataAutoSyncService.test.ts
+++ b/src/vs/platform/userDataSync/test/common/userDataAutoSyncService.test.ts
@@ -40,7 +40,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		await (await client.instantiationService.get(IUserDataSyncService).createSyncTask()).run();
 		target.reset();

-		const testObject: UserDataAutoSyncService = client.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: UserDataAutoSyncService = disposableStore.add(client.instantiationService.createInstance(TestUserDataAutoSyncService));

 		// Trigger auto sync with settings change
 		await testObject.triggerSync([SyncResource.Settings], false, false);
@@ -62,7 +62,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		await (await client.instantiationService.get(IUserDataSyncService).createSyncTask()).run();
 		target.reset();

-		const testObject: UserDataAutoSyncService = client.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: UserDataAutoSyncService = disposableStore.add(client.instantiationService.createInstance(TestUserDataAutoSyncService));

 		// Trigger auto sync with settings change multiple times
 		for (let counter = 0; counter < 2; counter++) {
@@ -88,7 +88,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		await (await client.instantiationService.get(IUserDataSyncService).createSyncTask()).run();
 		target.reset();

-		const testObject: UserDataAutoSyncService = client.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: UserDataAutoSyncService = disposableStore.add(client.instantiationService.createInstance(TestUserDataAutoSyncService));

 		// Trigger auto sync with window focus once
 		await testObject.triggerSync(['windowFocus'], true, false);
@@ -110,7 +110,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		await (await client.instantiationService.get(IUserDataSyncService).createSyncTask()).run();
 		target.reset();

-		const testObject: UserDataAutoSyncService = client.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: UserDataAutoSyncService = disposableStore.add(client.instantiationService.createInstance(TestUserDataAutoSyncService));

 		// Trigger auto sync with window focus multiple times
 		for (let counter = 0; counter < 2; counter++) {
@@ -129,7 +129,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		const target = new UserDataSyncTestServer();
 		const client = disposableStore.add(new UserDataSyncClient(target));
 		await client.setUp();
-		const testObject: TestUserDataAutoSyncService = client.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(client.instantiationService.createInstance(TestUserDataAutoSyncService));

 		await testObject.sync();

@@ -165,7 +165,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		const target = new UserDataSyncTestServer();
 		const client = disposableStore.add(new UserDataSyncClient(target));
 		await client.setUp();
-		const testObject: TestUserDataAutoSyncService = client.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(client.instantiationService.createInstance(TestUserDataAutoSyncService));

 		// Sync once and reset requests
 		await testObject.sync();
@@ -185,7 +185,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		const target = new UserDataSyncTestServer();
 		const client = disposableStore.add(new UserDataSyncClient(target));
 		await client.setUp();
-		const testObject: TestUserDataAutoSyncService = client.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(client.instantiationService.createInstance(TestUserDataAutoSyncService));

 		// Sync once and reset requests
 		await testObject.sync();
@@ -220,7 +220,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		const target = new UserDataSyncTestServer();
 		const client = disposableStore.add(new UserDataSyncClient(target));
 		await client.setUp();
-		const testObject: TestUserDataAutoSyncService = client.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(client.instantiationService.createInstance(TestUserDataAutoSyncService));

 		// Sync once and reset requests
 		await testObject.sync();
@@ -250,7 +250,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		// Set up and sync from the test client
 		const testClient = disposableStore.add(new UserDataSyncClient(target));
 		await testClient.setUp();
-		const testObject: TestUserDataAutoSyncService = testClient.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(testClient.instantiationService.createInstance(TestUserDataAutoSyncService));
 		await testObject.sync();

 		// Reset from the first client
@@ -279,7 +279,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		// Set up and sync from the test client
 		const testClient = disposableStore.add(new UserDataSyncClient(target));
 		await testClient.setUp();
-		const testObject: TestUserDataAutoSyncService = testClient.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(testClient.instantiationService.createInstance(TestUserDataAutoSyncService));
 		await testObject.sync();

 		// Disable current machine
@@ -311,7 +311,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		// Set up and sync from the test client
 		const testClient = disposableStore.add(new UserDataSyncClient(target));
 		await testClient.setUp();
-		const testObject: TestUserDataAutoSyncService = testClient.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(testClient.instantiationService.createInstance(TestUserDataAutoSyncService));
 		await testObject.sync();

 		// Remove current machine
@@ -339,7 +339,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		// Set up and sync from the test client
 		const testClient = disposableStore.add(new UserDataSyncClient(target));
 		await testClient.setUp();
-		const testObject: TestUserDataAutoSyncService = testClient.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(testClient.instantiationService.createInstance(TestUserDataAutoSyncService));
 		await testObject.sync();

 		// Reset from the first client
@@ -371,7 +371,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		// Set up and sync from the test client
 		const testClient = disposableStore.add(new UserDataSyncClient(target));
 		await testClient.setUp();
-		const testObject: TestUserDataAutoSyncService = testClient.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(testClient.instantiationService.createInstance(TestUserDataAutoSyncService));

 		const errorPromise = Event.toPromise(testObject.onError);
 		while (target.requests.length < 5) {
@@ -389,7 +389,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		// Set up and sync from the test client
 		const testClient = disposableStore.add(new UserDataSyncClient(target));
 		await testClient.setUp();
-		const testObject: TestUserDataAutoSyncService = testClient.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(testClient.instantiationService.createInstance(TestUserDataAutoSyncService));

 		while (target.requests.length < 5) {
 			await testObject.sync();
@@ -407,7 +407,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		// Set up and sync from the test client
 		const testClient = disposableStore.add(new UserDataSyncClient(target));
 		await testClient.setUp();
-		const testObject: TestUserDataAutoSyncService = testClient.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(testClient.instantiationService.createInstance(TestUserDataAutoSyncService));

 		await testObject.triggerSync(['some reason'], true, true);
 		assert.equal(target.requestsWithAllHeaders[0].headers!['Cache-Control'], 'no-cache');
@@ -419,7 +419,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
 		// Set up and sync from the test client
 		const testClient = disposableStore.add(new UserDataSyncClient(target));
 		await testClient.setUp();
-		const testObject: TestUserDataAutoSyncService = testClient.instantiationService.createInstance(TestUserDataAutoSyncService);
+		const testObject: TestUserDataAutoSyncService = disposableStore.add(testClient.instantiationService.createInstance(TestUserDataAutoSyncService));

 		await testObject.triggerSync(['some reason'], true, false);
 		assert.equal(target.requestsWithAllHeaders[0].headers!['Cache-Control'], undefined);
--- a/src/vs/platform/userDataSync/test/common/userDataSyncClient.ts
+++ b/src/vs/platform/userDataSync/test/common/userDataSyncClient.ts
@@ -83,9 +83,9 @@ export class UserDataSyncClient extends Disposable {
 		fileService.registerProvider(Schemas.inMemory, new InMemoryFileSystemProvider());
 		this.instantiationService.stub(IFileService, fileService);

-		this.instantiationService.stub(IStorageService, new InMemoryStorageService());
+		this.instantiationService.stub(IStorageService, this._register(new InMemoryStorageService()));

-		const configurationService = new ConfigurationService(environmentService.settingsResource, fileService);
+		const configurationService = this._register(new ConfigurationService(environmentService.settingsResource, fileService));
 		await configurationService.initialize();
 		this.instantiationService.stub(IConfigurationService, configurationService);

@@ -93,20 +93,20 @@ export class UserDataSyncClient extends Disposable {

 		this.instantiationService.stub(IUserDataSyncLogService, logService);
 		this.instantiationService.stub(ITelemetryService, NullTelemetryService);
-		this.instantiationService.stub(IUserDataSyncStoreManagementService, this.instantiationService.createInstance(UserDataSyncStoreManagementService));
-		this.instantiationService.stub(IUserDataSyncStoreService, this.instantiationService.createInstance(UserDataSyncStoreService));
+		this.instantiationService.stub(IUserDataSyncStoreManagementService, this._register(this.instantiationService.createInstance(UserDataSyncStoreManagementService)));
+		this.instantiationService.stub(IUserDataSyncStoreService, this._register(this.instantiationService.createInstance(UserDataSyncStoreService)));

-		const userDataSyncAccountService: IUserDataSyncAccountService = this.instantiationService.createInstance(UserDataSyncAccountService);
+		const userDataSyncAccountService: IUserDataSyncAccountService = this._register(this.instantiationService.createInstance(UserDataSyncAccountService));
 		await userDataSyncAccountService.updateAccount({ authenticationProviderId: 'authenticationProviderId', token: 'token' });
 		this.instantiationService.stub(IUserDataSyncAccountService, userDataSyncAccountService);

-		this.instantiationService.stub(IUserDataSyncMachinesService, this.instantiationService.createInstance(UserDataSyncMachinesService));
-		this.instantiationService.stub(IUserDataSyncBackupStoreService, this.instantiationService.createInstance(UserDataSyncBackupStoreService));
+		this.instantiationService.stub(IUserDataSyncMachinesService, this._register(this.instantiationService.createInstance(UserDataSyncMachinesService)));
+		this.instantiationService.stub(IUserDataSyncBackupStoreService, this._register(this.instantiationService.createInstance(UserDataSyncBackupStoreService)));
 		this.instantiationService.stub(IUserDataSyncUtilService, new TestUserDataSyncUtilService());
-		this.instantiationService.stub(IUserDataSyncResourceEnablementService, this.instantiationService.createInstance(UserDataSyncResourceEnablementService));
+		this.instantiationService.stub(IUserDataSyncResourceEnablementService, this._register(this.instantiationService.createInstance(UserDataSyncResourceEnablementService)));

-		this.instantiationService.stub(IGlobalExtensionEnablementService, this.instantiationService.createInstance(GlobalExtensionEnablementService));
-		this.instantiationService.stub(IExtensionsStorageSyncService, this.instantiationService.createInstance(ExtensionsStorageSyncService));
+		this.instantiationService.stub(IGlobalExtensionEnablementService, this._register(this.instantiationService.createInstance(GlobalExtensionEnablementService)));
+		this.instantiationService.stub(IExtensionsStorageSyncService, this._register(this.instantiationService.createInstance(ExtensionsStorageSyncService)));
 		this.instantiationService.stub(IIgnoredExtensionsManagementService, this.instantiationService.createInstance(IgnoredExtensionsManagementService));
 		this.instantiationService.stub(IExtensionManagementService, <Partial<IExtensionManagementService>>{
 			async getInstalled() { return []; },
@@ -118,8 +118,8 @@ export class UserDataSyncClient extends Disposable {
 			async getCompatibleExtension() { return null; }
 		});

-		this.instantiationService.stub(IUserDataAutoSyncEnablementService, this.instantiationService.createInstance(UserDataAutoSyncEnablementService));
-		this.instantiationService.stub(IUserDataSyncService, this.instantiationService.createInstance(UserDataSyncService));
+		this.instantiationService.stub(IUserDataAutoSyncEnablementService, this._register(this.instantiationService.createInstance(UserDataAutoSyncEnablementService)));
+		this.instantiationService.stub(IUserDataSyncService, this._register(this.instantiationService.createInstance(UserDataSyncService)));

 		if (!empty) {
 			await fileService.writeFile(environmentService.settingsResource, VSBuffer.fromString(JSON.stringify({})));
--- a/src/vs/platform/userDataSync/test/common/userDataSyncStoreService.test.ts
+++ b/src/vs/platform/userDataSync/test/common/userDataSyncStoreService.test.ts
@@ -58,7 +58,7 @@ suite('UserDataSyncStoreManagementService', () => {
 			authenticationProviders: [{ id: 'configuredAuthProvider', scopes: [] }]
 		};

-		const testObject: IUserDataSyncStoreManagementService = client.instantiationService.createInstance(UserDataSyncStoreManagementService);
+		const testObject: IUserDataSyncStoreManagementService = disposableStore.add(client.instantiationService.createInstance(UserDataSyncStoreManagementService));

 		assert.equal(testObject.userDataSyncStore?.url.toString(), expected.url.toString());
 		assert.equal(testObject.userDataSyncStore?.defaultUrl.toString(), expected.defaultUrl.toString());
@@ -419,7 +419,7 @@ suite('UserDataSyncStoreService', () => {
 			await testObject.manifest();
 		} catch (e) { }

-		const target = client.instantiationService.createInstance(UserDataSyncStoreService);
+		const target = disposableStore.add(client.instantiationService.createInstance(UserDataSyncStoreService));
 		assert.equal(target.donotMakeRequestsUntil?.getTime(), testObject.donotMakeRequestsUntil?.getTime());
 	});

@@ -434,7 +434,7 @@ suite('UserDataSyncStoreService', () => {
 		} catch (e) { }

 		await timeout(300);
-		const target = client.instantiationService.createInstance(UserDataSyncStoreService);
+		const target = disposableStore.add(client.instantiationService.createInstance(UserDataSyncStoreService));
 		assert.ok(!target.donotMakeRequestsUntil);
 	});