@azure/msal-browser 4.13.2 → 4.15.0

package/dist/cache/BrowserCacheManager.mjs

@@ -1,6 +1,6 @@
-/*! @azure/msal-browser v4.13.2 2025-06-18 */
+/*! @azure/msal-browser v4.15.0 2025-07-08 */
 'use strict';
-import { CacheManager, AccountEntity, invokeAsync, PerformanceEvents, CredentialType, createClientAuthError, ClientAuthErrorCodes, CacheHelpers, Constants, PersistentCacheKeys, StringUtils, TimeUtils, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION } from '@azure/msal-common/browser';
+import { CacheManager, createCacheError, CacheErrorCodes, invokeAsync, PerformanceEvents, AccountEntity, CacheHelpers, Constants, PersistentCacheKeys, TimeUtils, StringUtils, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION } from '@azure/msal-common/browser';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { StaticCacheKeys, BrowserCacheLocation, InMemoryCacheKeys, TemporaryCacheKeys, INTERACTION_TYPE } from '../utils/BrowserConstants.mjs';
 import { LocalStorage } from './LocalStorage.mjs';
@@ -49,7 +49,7 @@ class BrowserCacheManager extends CacheManager {
             this.performanceClient.addFields({ previousLibraryVersion: previousVersion }, correlationId);
         }
         if (previousVersion !== version) {
-            this.browserStorage.setItem(StaticCacheKeys.VERSION, version);
+            this.setItem(StaticCacheKeys.VERSION, version, correlationId);
         }
     }
     /**
@@ -73,22 +73,111 @@ class BrowserCacheManager extends CacheManager {
             return null;
         }
     }
+    /**
+     * Helper to setItem in browser storage, with cleanup in case of quota errors
+     * @param key
+     * @param 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;
+                }
+            }
+        }
+    }
+    /**
+     * Helper to setUserData in browser storage, with cleanup in case of quota errors
+     * @param key
+     * @param value
+     * @param correlationId
+     */
+    async setUserData(key, value, correlationId, timestamp) {
+        let accessTokenKeys = [];
+        const maxRetries = 20;
+        for (let i = 0; i <= maxRetries; i++) {
+            try {
+                await invokeAsync(this.browserStorage.setUserData.bind(this.browserStorage), PerformanceEvents.SetUserData, this.logger, this.performanceClient)(key, value, correlationId, timestamp);
+                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) {
+                        accessTokenKeys = this.getTokenKeys().accessToken;
+                    }
+                    if (accessTokenKeys.length <= i) {
+                        // Nothing left 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;
+                }
+            }
+        }
+    }
     /**
      * Reads account from cache, deserializes it into an account entity and returns it.
      * If account is not found from the key, returns null and removes key from map.
      * @param accountKey
      * @returns
      */
-    getAccount(accountKey) {
+    getAccount(accountKey, correlationId) {
         this.logger.trace("BrowserCacheManager.getAccount called");
         const serializedAccount = this.browserStorage.getUserData(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);
@@ -100,8 +189,10 @@ class BrowserCacheManager extends CacheManager {
     async setAccount(account, correlationId) {
         this.logger.trace("BrowserCacheManager.setAccount called");
         const key = account.generateAccountKey();
-        await invokeAsync(this.browserStorage.setUserData.bind(this.browserStorage), PerformanceEvents.SetUserData, this.logger, this.performanceClient)(key, JSON.stringify(account), correlationId);
-        const wasAdded = this.addAccountKeyToMap(key);
+        const timestamp = Date.now().toString();
+        account.lastUpdatedAt = timestamp;
+        await this.setUserData(key, JSON.stringify(account), correlationId, timestamp);
+        const wasAdded = this.addAccountKeyToMap(key, correlationId);
         /**
          * @deprecated - Remove this in next major version in favor of more consistent LOGIN event
          */
@@ -122,14 +213,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.browserStorage.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
+            this.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys), correlationId);
             this.logger.verbose("BrowserCacheManager.addAccountKeyToMap account key added");
             return true;
         }
@@ -142,14 +233,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.browserStorage.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 {
@@ -162,7 +260,7 @@ class BrowserCacheManager extends CacheManager {
      */
     removeAccount(key, correlationId) {
         super.removeAccount(key, correlationId);
-        this.removeAccountKeyFromMap(key);
+        this.removeAccountKeyFromMap(key, correlationId);
     }
     /**
      * Removes credentials associated with the provided account
@@ -181,25 +279,60 @@ class BrowserCacheManager extends CacheManager {
      * 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);
+        const tokenKeys = this.getTokenKeys();
+        const idRemoval = tokenKeys.idToken.indexOf(key);
+        if (idRemoval > -1) {
+            this.logger.info("idToken removed from tokenKeys map");
+            tokenKeys.idToken.splice(idRemoval, 1);
+            this.setTokenKeys(tokenKeys, correlationId);
+        }
     }
     /**
      * Removes given accessToken from the cache and from the key map
      * @param key
      */
-    removeAccessToken(key, correlationId) {
+    removeAccessToken(key, correlationId, updateTokenKeys = true) {
         super.removeAccessToken(key, correlationId);
-        this.removeTokenKey(key, CredentialType.ACCESS_TOKEN);
+        updateTokenKeys && this.removeAccessTokenKeys([key], correlationId);
+    }
+    /**
+     * Remove access token key from the key map
+     * @param key
+     * @param correlationId
+     * @param tokenKeys
+     */
+    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);
+        const tokenKeys = this.getTokenKeys();
+        const refreshRemoval = tokenKeys.refreshToken.indexOf(key);
+        if (refreshRemoval > -1) {
+            this.logger.info("refreshToken removed from tokenKeys map");
+            tokenKeys.refreshToken.splice(refreshRemoval, 1);
+            this.setTokenKeys(tokenKeys, correlationId);
+        }
     }
     /**
      * Gets the keys for the cached tokens associated with this clientId
@@ -209,101 +342,37 @@ class BrowserCacheManager extends CacheManager {
         return getTokenKeys(this.clientId, this.browserStorage);
     }
     /**
-     * Adds the given key to the token key map
-     * @param key
-     * @param type
+     * Stores the token keys in the cache
+     * @param tokenKeys
+     * @param correlationId
+     * @returns
      */
-    addTokenKey(key, type) {
-        this.logger.trace("BrowserCacheManager addTokenKey called");
-        const tokenKeys = this.getTokenKeys();
-        switch (type) {
-            case CredentialType.ID_TOKEN:
-                if (tokenKeys.idToken.indexOf(key) === -1) {
-                    this.logger.info("BrowserCacheManager: addTokenKey - idToken added to map");
-                    tokenKeys.idToken.push(key);
-                }
-                break;
-            case CredentialType.ACCESS_TOKEN:
-                if (tokenKeys.accessToken.indexOf(key) === -1) {
-                    this.logger.info("BrowserCacheManager: addTokenKey - accessToken added to map");
-                    tokenKeys.accessToken.push(key);
-                }
-                break;
-            case CredentialType.REFRESH_TOKEN:
-                if (tokenKeys.refreshToken.indexOf(key) === -1) {
-                    this.logger.info("BrowserCacheManager: addTokenKey - refreshToken added to map");
-                    tokenKeys.refreshToken.push(key);
-                }
-                break;
-            default:
-                this.logger.error(`BrowserCacheManager:addTokenKey - CredentialType provided invalid. CredentialType: ${type}`);
-                throw createClientAuthError(ClientAuthErrorCodes.unexpectedCredentialType);
+    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;
         }
-        this.browserStorage.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
-    }
-    /**
-     * Removes the given key from the token key map
-     * @param key
-     * @param type
-     */
-    removeTokenKey(key, type) {
-        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`);
-                const idRemoval = tokenKeys.idToken.indexOf(key);
-                if (idRemoval > -1) {
-                    this.logger.info("BrowserCacheManager: removeTokenKey - idToken removed from map");
-                    tokenKeys.idToken.splice(idRemoval, 1);
-                }
-                else {
-                    this.logger.info("BrowserCacheManager: removeTokenKey - idToken does not exist in map. Either it was previously removed or it was never added.");
-                }
-                break;
-            case CredentialType.ACCESS_TOKEN:
-                this.logger.infoPii(`BrowserCacheManager: removeTokenKey - attempting to remove accessToken with key: ${key} from map`);
-                const accessRemoval = tokenKeys.accessToken.indexOf(key);
-                if (accessRemoval > -1) {
-                    this.logger.info("BrowserCacheManager: removeTokenKey - accessToken removed from map");
-                    tokenKeys.accessToken.splice(accessRemoval, 1);
-                }
-                else {
-                    this.logger.info("BrowserCacheManager: removeTokenKey - accessToken does not exist in map. Either it was previously removed or it was never added.");
-                }
-                break;
-            case CredentialType.REFRESH_TOKEN:
-                this.logger.infoPii(`BrowserCacheManager: removeTokenKey - attempting to remove refreshToken with key: ${key} from map`);
-                const refreshRemoval = tokenKeys.refreshToken.indexOf(key);
-                if (refreshRemoval > -1) {
-                    this.logger.info("BrowserCacheManager: removeTokenKey - refreshToken removed from map");
-                    tokenKeys.refreshToken.splice(refreshRemoval, 1);
-                }
-                else {
-                    this.logger.info("BrowserCacheManager: removeTokenKey - refreshToken does not exist in map. Either it was previously removed or it was never added.");
-                }
-                break;
-            default:
-                this.logger.error(`BrowserCacheManager:removeTokenKey - CredentialType provided invalid. CredentialType: ${type}`);
-                throw createClientAuthError(ClientAuthErrorCodes.unexpectedCredentialType);
+        else {
+            this.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys), correlationId);
         }
-        this.browserStorage.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
     }
     /**
      * generates idToken entity from a string
      * @param idTokenKey
      */
-    getIdTokenCredential(idTokenKey) {
+    getIdTokenCredential(idTokenKey, correlationId) {
         const value = this.browserStorage.getUserData(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");
@@ -316,25 +385,31 @@ class BrowserCacheManager extends CacheManager {
     async setIdTokenCredential(idToken, correlationId) {
         this.logger.trace("BrowserCacheManager.setIdTokenCredential called");
         const idTokenKey = CacheHelpers.generateCredentialKey(idToken);
-        await invokeAsync(this.browserStorage.setUserData.bind(this.browserStorage), PerformanceEvents.SetUserData, this.logger, this.performanceClient)(idTokenKey, JSON.stringify(idToken), correlationId);
-        this.addTokenKey(idTokenKey, CredentialType.ID_TOKEN);
+        const timestamp = Date.now().toString();
+        idToken.lastUpdatedAt = timestamp;
+        await this.setUserData(idTokenKey, JSON.stringify(idToken), correlationId, timestamp);
+        const tokenKeys = this.getTokenKeys();
+        if (tokenKeys.idToken.indexOf(idTokenKey) === -1) {
+            this.logger.info("BrowserCacheManager: addTokenKey - idToken added to map");
+            tokenKeys.idToken.push(idTokenKey);
+            this.setTokenKeys(tokenKeys, correlationId);
+        }
     }
     /**
      * generates accessToken entity from a string
      * @param key
      */
-    getAccessTokenCredential(accessTokenKey) {
+    getAccessTokenCredential(accessTokenKey, correlationId) {
         const value = this.browserStorage.getUserData(accessTokenKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getAccessTokenCredential: called, no cache hit");
-            this.removeTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN);
+            this.removeAccessTokenKeys([accessTokenKey], 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");
@@ -347,25 +422,33 @@ class BrowserCacheManager extends CacheManager {
     async setAccessTokenCredential(accessToken, correlationId) {
         this.logger.trace("BrowserCacheManager.setAccessTokenCredential called");
         const accessTokenKey = CacheHelpers.generateCredentialKey(accessToken);
-        await invokeAsync(this.browserStorage.setUserData.bind(this.browserStorage), PerformanceEvents.SetUserData, this.logger, this.performanceClient)(accessTokenKey, JSON.stringify(accessToken), correlationId);
-        this.addTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN);
+        const timestamp = Date.now().toString();
+        accessToken.lastUpdatedAt = timestamp;
+        await this.setUserData(accessTokenKey, JSON.stringify(accessToken), correlationId, timestamp);
+        const tokenKeys = this.getTokenKeys();
+        const index = tokenKeys.accessToken.indexOf(accessTokenKey);
+        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(accessTokenKey);
+        this.setTokenKeys(tokenKeys, correlationId);
     }
     /**
      * generates refreshToken entity from a string
      * @param refreshTokenKey
      */
-    getRefreshTokenCredential(refreshTokenKey) {
+    getRefreshTokenCredential(refreshTokenKey, correlationId) {
         const value = this.browserStorage.getUserData(refreshTokenKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: called, no cache hit");
-            this.removeTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN);
+            this.removeRefreshToken(refreshTokenKey, 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");
@@ -378,8 +461,15 @@ class BrowserCacheManager extends CacheManager {
     async setRefreshTokenCredential(refreshToken, correlationId) {
         this.logger.trace("BrowserCacheManager.setRefreshTokenCredential called");
         const refreshTokenKey = CacheHelpers.generateCredentialKey(refreshToken);
-        await invokeAsync(this.browserStorage.setUserData.bind(this.browserStorage), PerformanceEvents.SetUserData, this.logger, this.performanceClient)(refreshTokenKey, JSON.stringify(refreshToken), correlationId);
-        this.addTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN);
+        const timestamp = Date.now().toString();
+        refreshToken.lastUpdatedAt = timestamp;
+        await this.setUserData(refreshTokenKey, JSON.stringify(refreshToken), correlationId, timestamp);
+        const tokenKeys = this.getTokenKeys();
+        if (tokenKeys.refreshToken.indexOf(refreshTokenKey) === -1) {
+            this.logger.info("BrowserCacheManager: addTokenKey - refreshToken added to map");
+            tokenKeys.refreshToken.push(refreshTokenKey);
+            this.setTokenKeys(tokenKeys, correlationId);
+        }
     }
     /**
      * fetch appMetadata entity from the platform cache
@@ -404,10 +494,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.browserStorage.setItem(appMetadataKey, JSON.stringify(appMetadata));
+        this.setItem(appMetadataKey, JSON.stringify(appMetadata), correlationId);
     }
     /**
      * fetch server telemetry entity from the platform cache
@@ -433,9 +523,9 @@ class BrowserCacheManager extends CacheManager {
      * @param serverTelemetryKey
      * @param serverTelemetry
      */
-    setServerTelemetry(serverTelemetryKey, serverTelemetry) {
+    setServerTelemetry(serverTelemetryKey, serverTelemetry, correlationId) {
         this.logger.trace("BrowserCacheManager.setServerTelemetry called");
-        this.browserStorage.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry));
+        this.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry), correlationId);
     }
     /**
      *
@@ -493,7 +583,7 @@ class BrowserCacheManager extends CacheManager {
     /**
      * Gets the active account
      */
-    getActiveAccount() {
+    getActiveAccount(correlationId) {
         const activeAccountKeyFilters = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
         const activeAccountValueFilters = this.browserStorage.getItem(activeAccountKeyFilters);
         if (!activeAccountValueFilters) {
@@ -507,7 +597,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;
@@ -516,7 +606,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);
         if (account) {
             this.logger.verbose("setActiveAccount: Active account set");
@@ -524,8 +614,9 @@ class BrowserCacheManager extends CacheManager {
                 homeAccountId: account.homeAccountId,
                 localAccountId: account.localAccountId,
                 tenantId: account.tenantId,
+                lastUpdatedAt: TimeUtils.nowSeconds().toString(),
             };
-            this.browserStorage.setItem(activeAccountKey, JSON.stringify(activeAccountValue));
+            this.setItem(activeAccountKey, JSON.stringify(activeAccountValue), correlationId);
         }
         else {
             this.logger.verbose("setActiveAccount: No account passed, active account not set");
@@ -557,9 +648,9 @@ class BrowserCacheManager extends CacheManager {
      * @param throttlingCacheKey
      * @param throttlingCache
      */
-    setThrottlingCache(throttlingCacheKey, throttlingCache) {
+    setThrottlingCache(throttlingCacheKey, throttlingCache, correlationId) {
         this.logger.trace("BrowserCacheManager.setThrottlingCache called");
-        this.browserStorage.setItem(throttlingCacheKey, JSON.stringify(throttlingCache));
+        this.setItem(throttlingCacheKey, JSON.stringify(throttlingCache), correlationId);
     }
     /**
      * Gets cache item with given key.
@@ -638,7 +729,7 @@ class BrowserCacheManager extends CacheManager {
     clear(correlationId) {
         // Removes all accounts and their credentials
         this.removeAllAccounts(correlationId);
-        this.removeAppMetadata();
+        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 ||
@@ -667,7 +758,7 @@ class BrowserCacheManager extends CacheManager {
         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())) {
                 this.removeAccessToken(key, correlationId);