@azure/msal-browser 3.28.1 → 3.30.0

package/dist/cache/BrowserCacheManager.mjs

@@ -1,6 +1,6 @@
-/*! @azure/msal-browser v3.28.1 2025-01-14 */
+/*! @azure/msal-browser v3.30.0 2025-08-05 */
 'use strict';
-import { CacheManager, CredentialType, CacheHelpers, AccountEntity, createClientAuthError, ClientAuthErrorCodes, Constants, PersistentCacheKeys, PerformanceEvents, StringUtils, ProtocolUtils, AuthToken, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION, CcsCredentialType } from '@azure/msal-common/browser';
+import { CacheManager, CredentialType, CacheHelpers, AccountEntity, createCacheError, CacheErrorCodes, createClientAuthError, ClientAuthErrorCodes, Constants, PersistentCacheKeys, PerformanceEvents, StringUtils, ProtocolUtils, AuthToken, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION, CcsCredentialType } from '@azure/msal-common/browser';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { BrowserCacheLocation, StaticCacheKeys, InMemoryCacheKeys, TemporaryCacheKeys } from '../utils/BrowserConstants.mjs';
 import { LocalStorage } from './LocalStorage.mjs';
@@ -10,6 +10,7 @@ import { extractBrowserRequestState } from '../utils/BrowserProtocolUtils.mjs';
 import { base64Decode } from '../encode/Base64Decode.mjs';
 import { base64Encode } from '../encode/Base64Encode.mjs';
 import { CookieStorage } from './CookieStorage.mjs';
+import { version } from '../packageMetadata.mjs';
 import { noTokenRequestCacheError, unableToParseTokenRequestCacheError, noCachedAuthorityError, interactionInProgress } from '../error/BrowserAuthErrorCodes.mjs';
 
 /*
@@ -64,6 +65,13 @@ class BrowserCacheManager extends CacheManager {
      * @param storeAuthStateInCookie
      */
     migrateCacheEntries() {
+        const previousVersion = this.browserStorage.getItem(StaticCacheKeys.VERSION);
+        if (previousVersion) {
+            this.logger.info(`MSAL.js was last initialized with version ${previousVersion}`);
+        }
+        if (previousVersion !== version) {
+            this.browserStorage.setItem(StaticCacheKeys.VERSION, version);
+        }
         const idTokenKey = `${Constants.CACHE_PREFIX}.${PersistentCacheKeys.ID_TOKEN}`;
         const clientInfoKey = `${Constants.CACHE_PREFIX}.${PersistentCacheKeys.CLIENT_INFO}`;
         const errorKey = `${Constants.CACHE_PREFIX}.${PersistentCacheKeys.ERROR}`;
@@ -98,6 +106,7 @@ class BrowserCacheManager extends CacheManager {
      */
     createKeyMaps() {
         this.logger.trace("BrowserCacheManager - createKeyMaps called.");
+        const correlationId = this.cryptoImpl.createNewGuid();
         const accountKeys = this.getItem(StaticCacheKeys.ACCOUNT_KEYS);
         const tokenKeys = this.getItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`);
         if (accountKeys && tokenKeys) {
@@ -119,8 +128,8 @@ class BrowserCacheManager extends CacheManager {
                                     this.logger.trace("BrowserCacheManager:createKeyMaps - idToken found, saving key to token key map");
                                     this.logger.tracePii(`BrowserCacheManager:createKeyMaps - idToken with key: ${key} found, saving key to token key map`);
                                     const idTokenEntity = credObj;
-                                    const newKey = this.updateCredentialCacheKey(key, idTokenEntity);
-                                    this.addTokenKey(newKey, CredentialType.ID_TOKEN);
+                                    const newKey = this.updateCredentialCacheKey(key, idTokenEntity, correlationId);
+                                    this.addTokenKey(newKey, CredentialType.ID_TOKEN, correlationId);
                                     return;
                                 }
                                 else {
@@ -134,8 +143,8 @@ class BrowserCacheManager extends CacheManager {
                                     this.logger.trace("BrowserCacheManager:createKeyMaps - accessToken found, saving key to token key map");
                                     this.logger.tracePii(`BrowserCacheManager:createKeyMaps - accessToken with key: ${key} found, saving key to token key map`);
                                     const accessTokenEntity = credObj;
-                                    const newKey = this.updateCredentialCacheKey(key, accessTokenEntity);
-                                    this.addTokenKey(newKey, CredentialType.ACCESS_TOKEN);
+                                    const newKey = this.updateCredentialCacheKey(key, accessTokenEntity, correlationId);
+                                    this.addTokenKey(newKey, CredentialType.ACCESS_TOKEN, correlationId);
                                     return;
                                 }
                                 else {
@@ -148,8 +157,8 @@ class BrowserCacheManager extends CacheManager {
                                     this.logger.trace("BrowserCacheManager:createKeyMaps - refreshToken found, saving key to token key map");
                                     this.logger.tracePii(`BrowserCacheManager:createKeyMaps - refreshToken with key: ${key} found, saving key to token key map`);
                                     const refreshTokenEntity = credObj;
-                                    const newKey = this.updateCredentialCacheKey(key, refreshTokenEntity);
-                                    this.addTokenKey(newKey, CredentialType.REFRESH_TOKEN);
+                                    const newKey = this.updateCredentialCacheKey(key, refreshTokenEntity, correlationId);
+                                    this.addTokenKey(newKey, CredentialType.REFRESH_TOKEN, correlationId);
                                     return;
                                 }
                                 else {
@@ -170,7 +179,7 @@ class BrowserCacheManager extends CacheManager {
                         AccountEntity.isAccountEntity(accountObj)) {
                         this.logger.trace("BrowserCacheManager:createKeyMaps - account found, saving key to account key map");
                         this.logger.tracePii(`BrowserCacheManager:createKeyMaps - account with key: ${key} found, saving key to account key map`);
-                        this.addAccountKeyToMap(key);
+                        this.addAccountKeyToMap(key, correlationId);
                     }
                 }
             }
@@ -209,17 +218,58 @@ class BrowserCacheManager extends CacheManager {
      * @param key
      * @param value
      */
-    setItem(key, value) {
-        this.browserStorage.setItem(key, value);
+    setItem(key, value, correlationId) {
+        let accessTokenKeys = [];
+        const maxRetries = 20;
+        for (let i = 0; i <= maxRetries; i++) {
+            try {
+                this.browserStorage.setItem(key, value);
+                if (i > 0) {
+                    // Finally update the token keys array with the tokens removed
+                    this.removeAccessTokenKeys(accessTokenKeys.slice(0, i), correlationId);
+                }
+                break; // If setItem succeeds, exit the loop
+            }
+            catch (e) {
+                const cacheError = createCacheError(e);
+                if (cacheError.errorCode ===
+                    CacheErrorCodes.cacheQuotaExceeded &&
+                    i < maxRetries) {
+                    if (!accessTokenKeys.length) {
+                        if (key ===
+                            `${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`) {
+                            // If we are currently trying to set the token keys, use the value we're trying to set
+                            accessTokenKeys = JSON.parse(value)
+                                .accessToken;
+                        }
+                        else {
+                            // If token keys have not been initialized, get them
+                            accessTokenKeys = this.getTokenKeys().accessToken;
+                        }
+                    }
+                    if (accessTokenKeys.length <= i) {
+                        // Nothing to remove, rethrow the error
+                        throw cacheError;
+                    }
+                    // When cache quota is exceeded, start removing access tokens until we can successfully set the item
+                    this.removeAccessToken(accessTokenKeys[i], correlationId, false // Don't save token keys yet, do it at the end
+                    );
+                }
+                else {
+                    // If the error is not a quota exceeded error, rethrow it
+                    throw cacheError;
+                }
+            }
+        }
     }
     /**
      * fetch the account entity from the platform cache
      * @param accountKey
      */
-    getAccount(accountKey, logger) {
+    getAccount(accountKey, correlationId, logger) {
         this.logger.trace("BrowserCacheManager.getAccount called");
-        const accountEntity = this.getCachedAccountEntity(accountKey);
-        return this.updateOutdatedCachedAccount(accountKey, accountEntity, logger);
+        const accountEntity = this.getCachedAccountEntity(accountKey, correlationId);
+        return this.updateOutdatedCachedAccount(accountKey, accountEntity, correlationId, logger);
     }
     /**
      * Reads account from cache, deserializes it into an account entity and returns it.
@@ -227,15 +277,14 @@ class BrowserCacheManager extends CacheManager {
      * @param accountKey
      * @returns
      */
-    getCachedAccountEntity(accountKey) {
+    getCachedAccountEntity(accountKey, correlationId) {
         const serializedAccount = this.getItem(accountKey);
         if (!serializedAccount) {
-            this.removeAccountKeyFromMap(accountKey);
+            this.removeAccountKeyFromMap(accountKey, correlationId);
             return null;
         }
         const parsedAccount = this.validateAndParseJson(serializedAccount);
         if (!parsedAccount || !AccountEntity.isAccountEntity(parsedAccount)) {
-            this.removeAccountKeyFromMap(accountKey);
             return null;
         }
         return CacheManager.toObject(new AccountEntity(), parsedAccount);
@@ -244,11 +293,12 @@ class BrowserCacheManager extends CacheManager {
      * set account entity in the platform cache
      * @param account
      */
-    setAccount(account) {
+    setAccount(account, correlationId) {
         this.logger.trace("BrowserCacheManager.setAccount called");
         const key = account.generateAccountKey();
-        this.setItem(key, JSON.stringify(account));
-        this.addAccountKeyToMap(key);
+        account.lastUpdatedAt = Date.now().toString();
+        this.setItem(key, JSON.stringify(account), correlationId);
+        this.addAccountKeyToMap(key, correlationId);
     }
     /**
      * Returns the array of account keys currently cached
@@ -267,14 +317,14 @@ class BrowserCacheManager extends CacheManager {
      * Add a new account to the key map
      * @param key
      */
-    addAccountKeyToMap(key) {
+    addAccountKeyToMap(key, correlationId) {
         this.logger.trace("BrowserCacheManager.addAccountKeyToMap called");
         this.logger.tracePii(`BrowserCacheManager.addAccountKeyToMap called with key: ${key}`);
         const accountKeys = this.getAccountKeys();
         if (accountKeys.indexOf(key) === -1) {
             // Only add key if it does not already exist in the map
             accountKeys.push(key);
-            this.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
+            this.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys), correlationId);
             this.logger.verbose("BrowserCacheManager.addAccountKeyToMap account key added");
         }
         else {
@@ -285,14 +335,21 @@ class BrowserCacheManager extends CacheManager {
      * Remove an account from the key map
      * @param key
      */
-    removeAccountKeyFromMap(key) {
+    removeAccountKeyFromMap(key, correlationId) {
         this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap called");
         this.logger.tracePii(`BrowserCacheManager.removeAccountKeyFromMap called with key: ${key}`);
         const accountKeys = this.getAccountKeys();
         const removalIndex = accountKeys.indexOf(key);
         if (removalIndex > -1) {
             accountKeys.splice(removalIndex, 1);
-            this.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
+            if (accountKeys.length === 0) {
+                // If no keys left, remove the map
+                this.removeItem(StaticCacheKeys.ACCOUNT_KEYS);
+                return;
+            }
+            else {
+                this.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys), correlationId);
+            }
             this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap account key removed");
         }
         else {
@@ -303,41 +360,60 @@ class BrowserCacheManager extends CacheManager {
      * Extends inherited removeAccount function to include removal of the account key from the map
      * @param key
      */
-    async removeAccount(key) {
-        void super.removeAccount(key);
-        this.removeAccountKeyFromMap(key);
+    async removeAccount(key, correlationId) {
+        void super.removeAccount(key, correlationId);
+        this.removeAccountKeyFromMap(key, correlationId);
     }
     /**
      * Remove account entity from the platform cache if it's outdated
      * @param accountKey
      */
-    removeOutdatedAccount(accountKey) {
+    removeOutdatedAccount(accountKey, correlationId) {
         this.removeItem(accountKey);
-        this.removeAccountKeyFromMap(accountKey);
+        this.removeAccountKeyFromMap(accountKey, correlationId);
     }
     /**
      * Removes given idToken from the cache and from the key map
      * @param key
      */
-    removeIdToken(key) {
-        super.removeIdToken(key);
-        this.removeTokenKey(key, CredentialType.ID_TOKEN);
+    removeIdToken(key, correlationId) {
+        super.removeIdToken(key, correlationId);
+        this.removeTokenKey(key, CredentialType.ID_TOKEN, correlationId);
     }
     /**
      * Removes given accessToken from the cache and from the key map
      * @param key
      */
-    async removeAccessToken(key) {
-        void super.removeAccessToken(key);
-        this.removeTokenKey(key, CredentialType.ACCESS_TOKEN);
+    removeAccessToken(key, correlationId, updateTokenKeys = true) {
+        super.removeAccessToken(key, correlationId);
+        this.performanceClient?.incrementFields({ accessTokensRemoved: 1 }, correlationId);
+        updateTokenKeys &&
+            this.removeTokenKey(key, CredentialType.ACCESS_TOKEN, correlationId);
+    }
+    removeAccessTokenKeys(keys, correlationId) {
+        this.logger.trace("removeAccessTokenKey called");
+        const tokenKeys = this.getTokenKeys();
+        let keysRemoved = 0;
+        keys.forEach((key) => {
+            const accessRemoval = tokenKeys.accessToken.indexOf(key);
+            if (accessRemoval > -1) {
+                tokenKeys.accessToken.splice(accessRemoval, 1);
+                keysRemoved++;
+            }
+        });
+        if (keysRemoved > 0) {
+            this.logger.info(`removed ${keysRemoved} accessToken keys from tokenKeys map`);
+            this.setTokenKeys(tokenKeys, correlationId);
+            return;
+        }
     }
     /**
      * Removes given refreshToken from the cache and from the key map
      * @param key
      */
-    removeRefreshToken(key) {
-        super.removeRefreshToken(key);
-        this.removeTokenKey(key, CredentialType.REFRESH_TOKEN);
+    removeRefreshToken(key, correlationId) {
+        super.removeRefreshToken(key, correlationId);
+        this.removeTokenKey(key, CredentialType.REFRESH_TOKEN, correlationId);
     }
     /**
      * Gets the keys for the cached tokens associated with this clientId
@@ -367,12 +443,30 @@ class BrowserCacheManager extends CacheManager {
             refreshToken: [],
         };
     }
+    /**
+     * Stores the token keys in the cache
+     * @param tokenKeys
+     * @param correlationId
+     * @returns
+     */
+    setTokenKeys(tokenKeys, correlationId) {
+        if (tokenKeys.idToken.length === 0 &&
+            tokenKeys.accessToken.length === 0 &&
+            tokenKeys.refreshToken.length === 0) {
+            // If no keys left, remove the map
+            this.removeItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`);
+            return;
+        }
+        else {
+            this.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys), correlationId);
+        }
+    }
     /**
      * Adds the given key to the token key map
      * @param key
      * @param type
      */
-    addTokenKey(key, type) {
+    addTokenKey(key, type, correlationId) {
         this.logger.trace("BrowserCacheManager addTokenKey called");
         const tokenKeys = this.getTokenKeys();
         switch (type) {
@@ -383,10 +477,12 @@ class BrowserCacheManager extends CacheManager {
                 }
                 break;
             case CredentialType.ACCESS_TOKEN:
-                if (tokenKeys.accessToken.indexOf(key) === -1) {
-                    this.logger.info("BrowserCacheManager: addTokenKey - accessToken added to map");
-                    tokenKeys.accessToken.push(key);
+                const index = tokenKeys.accessToken.indexOf(key);
+                if (index !== -1) {
+                    tokenKeys.accessToken.splice(index, 1); // Remove existing key before pushing to the end
                 }
+                this.logger.trace(`access token ${index === -1 ? "added to" : "updated in"} map`);
+                tokenKeys.accessToken.push(key);
                 break;
             case CredentialType.REFRESH_TOKEN:
                 if (tokenKeys.refreshToken.indexOf(key) === -1) {
@@ -398,16 +494,15 @@ class BrowserCacheManager extends CacheManager {
                 this.logger.error(`BrowserCacheManager:addTokenKey - CredentialType provided invalid. CredentialType: ${type}`);
                 throw createClientAuthError(ClientAuthErrorCodes.unexpectedCredentialType);
         }
-        this.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
+        this.setTokenKeys(tokenKeys, correlationId);
     }
     /**
      * Removes the given key from the token key map
      * @param key
      * @param type
      */
-    removeTokenKey(key, type) {
+    removeTokenKey(key, type, correlationId, tokenKeys = this.getTokenKeys()) {
         this.logger.trace("BrowserCacheManager removeTokenKey called");
-        const tokenKeys = this.getTokenKeys();
         switch (type) {
             case CredentialType.ID_TOKEN:
                 this.logger.infoPii(`BrowserCacheManager: removeTokenKey - attempting to remove idToken with key: ${key} from map`);
@@ -446,23 +541,22 @@ class BrowserCacheManager extends CacheManager {
                 this.logger.error(`BrowserCacheManager:removeTokenKey - CredentialType provided invalid. CredentialType: ${type}`);
                 throw createClientAuthError(ClientAuthErrorCodes.unexpectedCredentialType);
         }
-        this.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
+        this.setTokenKeys(tokenKeys, correlationId);
     }
     /**
      * generates idToken entity from a string
      * @param idTokenKey
      */
-    getIdTokenCredential(idTokenKey) {
+    getIdTokenCredential(idTokenKey, correlationId) {
         const value = this.getItem(idTokenKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getIdTokenCredential: called, no cache hit");
-            this.removeTokenKey(idTokenKey, CredentialType.ID_TOKEN);
+            this.removeIdToken(idTokenKey, correlationId);
             return null;
         }
         const parsedIdToken = this.validateAndParseJson(value);
         if (!parsedIdToken || !CacheHelpers.isIdTokenEntity(parsedIdToken)) {
             this.logger.trace("BrowserCacheManager.getIdTokenCredential: called, no cache hit");
-            this.removeTokenKey(idTokenKey, CredentialType.ID_TOKEN);
             return null;
         }
         this.logger.trace("BrowserCacheManager.getIdTokenCredential: cache hit");
@@ -472,28 +566,28 @@ class BrowserCacheManager extends CacheManager {
      * set IdToken credential to the platform cache
      * @param idToken
      */
-    setIdTokenCredential(idToken) {
+    setIdTokenCredential(idToken, correlationId) {
         this.logger.trace("BrowserCacheManager.setIdTokenCredential called");
         const idTokenKey = CacheHelpers.generateCredentialKey(idToken);
-        this.setItem(idTokenKey, JSON.stringify(idToken));
-        this.addTokenKey(idTokenKey, CredentialType.ID_TOKEN);
+        idToken.lastUpdatedAt = Date.now().toString();
+        this.setItem(idTokenKey, JSON.stringify(idToken), correlationId);
+        this.addTokenKey(idTokenKey, CredentialType.ID_TOKEN, correlationId);
     }
     /**
      * generates accessToken entity from a string
      * @param key
      */
-    getAccessTokenCredential(accessTokenKey) {
+    getAccessTokenCredential(accessTokenKey, correlationId) {
         const value = this.getItem(accessTokenKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getAccessTokenCredential: called, no cache hit");
-            this.removeTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN);
+            this.removeTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN, correlationId);
             return null;
         }
         const parsedAccessToken = this.validateAndParseJson(value);
         if (!parsedAccessToken ||
             !CacheHelpers.isAccessTokenEntity(parsedAccessToken)) {
             this.logger.trace("BrowserCacheManager.getAccessTokenCredential: called, no cache hit");
-            this.removeTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN);
             return null;
         }
         this.logger.trace("BrowserCacheManager.getAccessTokenCredential: cache hit");
@@ -503,28 +597,28 @@ class BrowserCacheManager extends CacheManager {
      * set accessToken credential to the platform cache
      * @param accessToken
      */
-    setAccessTokenCredential(accessToken) {
+    setAccessTokenCredential(accessToken, correlationId) {
         this.logger.trace("BrowserCacheManager.setAccessTokenCredential called");
         const accessTokenKey = CacheHelpers.generateCredentialKey(accessToken);
-        this.setItem(accessTokenKey, JSON.stringify(accessToken));
-        this.addTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN);
+        accessToken.lastUpdatedAt = Date.now().toString();
+        this.setItem(accessTokenKey, JSON.stringify(accessToken), correlationId);
+        this.addTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN, correlationId);
     }
     /**
      * generates refreshToken entity from a string
      * @param refreshTokenKey
      */
-    getRefreshTokenCredential(refreshTokenKey) {
+    getRefreshTokenCredential(refreshTokenKey, correlationId) {
         const value = this.getItem(refreshTokenKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: called, no cache hit");
-            this.removeTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN);
+            this.removeTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN, correlationId);
             return null;
         }
         const parsedRefreshToken = this.validateAndParseJson(value);
         if (!parsedRefreshToken ||
             !CacheHelpers.isRefreshTokenEntity(parsedRefreshToken)) {
             this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: called, no cache hit");
-            this.removeTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN);
             return null;
         }
         this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: cache hit");
@@ -534,11 +628,12 @@ class BrowserCacheManager extends CacheManager {
      * set refreshToken credential to the platform cache
      * @param refreshToken
      */
-    setRefreshTokenCredential(refreshToken) {
+    setRefreshTokenCredential(refreshToken, correlationId) {
         this.logger.trace("BrowserCacheManager.setRefreshTokenCredential called");
         const refreshTokenKey = CacheHelpers.generateCredentialKey(refreshToken);
-        this.setItem(refreshTokenKey, JSON.stringify(refreshToken));
-        this.addTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN);
+        refreshToken.lastUpdatedAt = Date.now().toString();
+        this.setItem(refreshTokenKey, JSON.stringify(refreshToken), correlationId);
+        this.addTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN, correlationId);
     }
     /**
      * fetch appMetadata entity from the platform cache
@@ -563,10 +658,10 @@ class BrowserCacheManager extends CacheManager {
      * set appMetadata entity to the platform cache
      * @param appMetadata
      */
-    setAppMetadata(appMetadata) {
+    setAppMetadata(appMetadata, correlationId) {
         this.logger.trace("BrowserCacheManager.setAppMetadata called");
         const appMetadataKey = CacheHelpers.generateAppMetadataKey(appMetadata);
-        this.setItem(appMetadataKey, JSON.stringify(appMetadata));
+        this.setItem(appMetadataKey, JSON.stringify(appMetadata), correlationId);
     }
     /**
      * fetch server telemetry entity from the platform cache
@@ -592,9 +687,9 @@ class BrowserCacheManager extends CacheManager {
      * @param serverTelemetryKey
      * @param serverTelemetry
      */
-    setServerTelemetry(serverTelemetryKey, serverTelemetry) {
+    setServerTelemetry(serverTelemetryKey, serverTelemetry, correlationId) {
         this.logger.trace("BrowserCacheManager.setServerTelemetry called");
-        this.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry));
+        this.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry), correlationId);
     }
     /**
      *
@@ -652,7 +747,7 @@ class BrowserCacheManager extends CacheManager {
     /**
      * Gets the active account
      */
-    getActiveAccount() {
+    getActiveAccount(correlationId) {
         const activeAccountKeyFilters = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
         const activeAccountValueFilters = this.getItem(activeAccountKeyFilters);
         if (!activeAccountValueFilters) {
@@ -666,11 +761,11 @@ class BrowserCacheManager extends CacheManager {
             }
             const activeAccount = this.getAccountInfoFilteredBy({
                 localAccountId: activeAccountValueLocal,
-            });
+            }, correlationId);
             if (activeAccount) {
                 this.logger.trace("BrowserCacheManager.getActiveAccount: Legacy active account cache schema found");
                 this.logger.trace("BrowserCacheManager.getActiveAccount: Adding active account filters cache schema");
-                this.setActiveAccount(activeAccount);
+                this.setActiveAccount(activeAccount, correlationId);
                 return activeAccount;
             }
             return null;
@@ -682,7 +777,7 @@ class BrowserCacheManager extends CacheManager {
                 homeAccountId: activeAccountValueObj.homeAccountId,
                 localAccountId: activeAccountValueObj.localAccountId,
                 tenantId: activeAccountValueObj.tenantId,
-            });
+            }, correlationId);
         }
         this.logger.trace("BrowserCacheManager.getActiveAccount: No active account found");
         return null;
@@ -691,7 +786,7 @@ class BrowserCacheManager extends CacheManager {
      * Sets the active account's localAccountId in cache
      * @param account
      */
-    setActiveAccount(account) {
+    setActiveAccount(account, correlationId) {
         const activeAccountKey = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
         const activeAccountKeyLocal = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT);
         if (account) {
@@ -700,9 +795,10 @@ class BrowserCacheManager extends CacheManager {
                 homeAccountId: account.homeAccountId,
                 localAccountId: account.localAccountId,
                 tenantId: account.tenantId,
+                lastUpdatedAt: Date.now().toString(),
             };
-            this.browserStorage.setItem(activeAccountKey, JSON.stringify(activeAccountValue));
-            this.browserStorage.setItem(activeAccountKeyLocal, account.localAccountId);
+            this.setItem(activeAccountKey, JSON.stringify(activeAccountValue), correlationId);
+            this.setItem(activeAccountKeyLocal, account.localAccountId, correlationId);
         }
         else {
             this.logger.verbose("setActiveAccount: No account passed, active account not set");
@@ -734,9 +830,9 @@ class BrowserCacheManager extends CacheManager {
      * @param throttlingCacheKey
      * @param throttlingCache
      */
-    setThrottlingCache(throttlingCacheKey, throttlingCache) {
+    setThrottlingCache(throttlingCacheKey, throttlingCache, correlationId) {
         this.logger.trace("BrowserCacheManager.setThrottlingCache called");
-        this.setItem(throttlingCacheKey, JSON.stringify(throttlingCache));
+        this.setItem(throttlingCacheKey, JSON.stringify(throttlingCache), correlationId);
     }
     /**
      * Gets cache item with given key.
@@ -812,10 +908,10 @@ class BrowserCacheManager extends CacheManager {
     /**
      * Clears all cache entries created by MSAL.
      */
-    async clear() {
+    async clear(correlationId) {
         // Removes all accounts and their credentials
-        await this.removeAllAccounts();
-        this.removeAppMetadata();
+        await this.removeAllAccounts(correlationId);
+        this.removeAppMetadata(correlationId);
         // Remove temp storage first to make sure any cookies are cleared
         this.temporaryCacheStorage.getKeys().forEach((cacheKey) => {
             if (cacheKey.indexOf(Constants.CACHE_PREFIX) !== -1 ||
@@ -841,19 +937,19 @@ class BrowserCacheManager extends CacheManager {
     async clearTokensAndKeysWithClaims(performanceClient, correlationId) {
         performanceClient.addQueueMeasurement(PerformanceEvents.ClearTokensAndKeysWithClaims, correlationId);
         const tokenKeys = this.getTokenKeys();
-        const removedAccessTokens = [];
+        let removedAccessTokens = 0;
         tokenKeys.accessToken.forEach((key) => {
             // if the access token has claims in its key, remove the token key and the token
-            const credential = this.getAccessTokenCredential(key);
+            const credential = this.getAccessTokenCredential(key, correlationId);
             if (credential?.requestedClaimsHash &&
                 key.includes(credential.requestedClaimsHash.toLowerCase())) {
-                removedAccessTokens.push(this.removeAccessToken(key));
+                this.removeAccessToken(key, correlationId);
+                removedAccessTokens++;
             }
         });
-        await Promise.all(removedAccessTokens);
         // warn if any access tokens are removed
-        if (removedAccessTokens.length > 0) {
-            this.logger.warning(`${removedAccessTokens.length} access tokens with claims in the cache keys have been removed from the cache.`);
+        if (removedAccessTokens > 0) {
+            this.logger.warning(`${removedAccessTokens} access tokens with claims in the cache keys have been removed from the cache.`);
         }
     }
     /**
@@ -1128,13 +1224,13 @@ class BrowserCacheManager extends CacheManager {
     /**
      * Updates a credential's cache key if the current cache key is outdated
      */
-    updateCredentialCacheKey(currentCacheKey, credential) {
+    updateCredentialCacheKey(currentCacheKey, credential, correlationId) {
         const updatedCacheKey = CacheHelpers.generateCredentialKey(credential);
         if (currentCacheKey !== updatedCacheKey) {
             const cacheItem = this.getItem(currentCacheKey);
             if (cacheItem) {
                 this.browserStorage.removeItem(currentCacheKey);
-                this.setItem(updatedCacheKey, cacheItem);
+                this.setItem(updatedCacheKey, cacheItem, correlationId);
                 this.logger.verbose(`Updated an outdated ${credential.credentialType} cache key`);
                 return updatedCacheKey;
             }
@@ -1169,7 +1265,7 @@ class BrowserCacheManager extends CacheManager {
             idToken: idTokenEntity,
             accessToken: accessTokenEntity,
         };
-        return this.saveCacheRecord(cacheRecord);
+        return this.saveCacheRecord(cacheRecord, result.correlationId);
     }
     /**
      * saves a cache record
@@ -1177,9 +1273,9 @@ class BrowserCacheManager extends CacheManager {
      * @param storeInCache {?StoreInCache}
      * @param correlationId {?string} correlation id
      */
-    async saveCacheRecord(cacheRecord, storeInCache, correlationId) {
+    async saveCacheRecord(cacheRecord, correlationId, storeInCache) {
         try {
-            await super.saveCacheRecord(cacheRecord, storeInCache, correlationId);
+            await super.saveCacheRecord(cacheRecord, correlationId, storeInCache);
         }
         catch (e) {
             if (e instanceof CacheError &&