@azure/msal-browser 3.28.1 → 3.30.0

package/src/cache/BrowserCacheManager.ts

@@ -39,6 +39,8 @@ import {
     CacheHelpers,
     StoreInCache,
     CacheError,
+    CacheErrorCodes,
+    createCacheError,
 } from "@azure/msal-common/browser";
 import { CacheOptions } from "../config/Configuration.js";
 import {
@@ -66,6 +68,7 @@ import { PopupRequest } from "../request/PopupRequest.js";
 import { base64Decode } from "../encode/Base64Decode.js";
 import { base64Encode } from "../encode/Base64Encode.js";
 import { CookieStorage } from "./CookieStorage.js";
+import { version } from "../packageMetadata.js";
 
 /**
  * This class implements the cache storage interface for MSAL through browser local or session storage.
@@ -146,6 +149,19 @@ export class BrowserCacheManager extends CacheManager {
      * @param storeAuthStateInCookie
      */
     protected migrateCacheEntries(): void {
+        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}`;
@@ -184,6 +200,7 @@ export class BrowserCacheManager extends CacheManager {
      */
     private createKeyMaps(): void {
         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}`
@@ -218,11 +235,13 @@ export class BrowserCacheManager extends CacheManager {
                                     const newKey =
                                         this.updateCredentialCacheKey(
                                             key,
-                                            idTokenEntity
+                                            idTokenEntity,
+                                            correlationId
                                         );
                                     this.addTokenKey(
                                         newKey,
-                                        CredentialType.ID_TOKEN
+                                        CredentialType.ID_TOKEN,
+                                        correlationId
                                     );
                                     return;
                                 } else {
@@ -248,11 +267,13 @@ export class BrowserCacheManager extends CacheManager {
                                     const newKey =
                                         this.updateCredentialCacheKey(
                                             key,
-                                            accessTokenEntity
+                                            accessTokenEntity,
+                                            correlationId
                                         );
                                     this.addTokenKey(
                                         newKey,
-                                        CredentialType.ACCESS_TOKEN
+                                        CredentialType.ACCESS_TOKEN,
+                                        correlationId
                                     );
                                     return;
                                 } else {
@@ -279,11 +300,13 @@ export class BrowserCacheManager extends CacheManager {
                                     const newKey =
                                         this.updateCredentialCacheKey(
                                             key,
-                                            refreshTokenEntity
+                                            refreshTokenEntity,
+                                            correlationId
                                         );
                                     this.addTokenKey(
                                         newKey,
-                                        CredentialType.REFRESH_TOKEN
+                                        CredentialType.REFRESH_TOKEN,
+                                        correlationId
                                     );
                                     return;
                                 } else {
@@ -316,7 +339,7 @@ export class BrowserCacheManager extends CacheManager {
                         this.logger.tracePii(
                             `BrowserCacheManager:createKeyMaps - account with key: ${key} found, saving key to account key map`
                         );
-                        this.addAccountKeyToMap(key);
+                        this.addAccountKeyToMap(key, correlationId);
                     }
                 }
             }
@@ -357,21 +380,77 @@ export class BrowserCacheManager extends CacheManager {
      * @param key
      * @param value
      */
-    setItem(key: string, value: string): void {
-        this.browserStorage.setItem(key, value);
+    setItem(key: string, value: string, correlationId: string): void {
+        let accessTokenKeys: Array<string> = [];
+        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) as TokenKeys)
+                                .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: string, logger?: Logger): AccountEntity | null {
+    getAccount(
+        accountKey: string,
+        correlationId: string,
+        logger?: Logger
+    ): AccountEntity | null {
         this.logger.trace("BrowserCacheManager.getAccount called");
-        const accountEntity = this.getCachedAccountEntity(accountKey);
+        const accountEntity = this.getCachedAccountEntity(
+            accountKey,
+            correlationId
+        );
 
         return this.updateOutdatedCachedAccount(
             accountKey,
             accountEntity,
+            correlationId,
             logger
         );
     }
@@ -382,16 +461,18 @@ export class BrowserCacheManager extends CacheManager {
      * @param accountKey
      * @returns
      */
-    getCachedAccountEntity(accountKey: string): AccountEntity | null {
+    getCachedAccountEntity(
+        accountKey: string,
+        correlationId: string
+    ): AccountEntity | null {
         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;
         }
 
@@ -405,11 +486,12 @@ export class BrowserCacheManager extends CacheManager {
      * set account entity in the platform cache
      * @param account
      */
-    setAccount(account: AccountEntity): void {
+    setAccount(account: AccountEntity, correlationId: string): void {
         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);
     }
 
     /**
@@ -433,7 +515,7 @@ export class BrowserCacheManager extends CacheManager {
      * Add a new account to the key map
      * @param key
      */
-    addAccountKeyToMap(key: string): void {
+    addAccountKeyToMap(key: string, correlationId: string): void {
         this.logger.trace("BrowserCacheManager.addAccountKeyToMap called");
         this.logger.tracePii(
             `BrowserCacheManager.addAccountKeyToMap called with key: ${key}`
@@ -444,7 +526,8 @@ export class BrowserCacheManager extends CacheManager {
             accountKeys.push(key);
             this.setItem(
                 StaticCacheKeys.ACCOUNT_KEYS,
-                JSON.stringify(accountKeys)
+                JSON.stringify(accountKeys),
+                correlationId
             );
             this.logger.verbose(
                 "BrowserCacheManager.addAccountKeyToMap account key added"
@@ -460,7 +543,7 @@ export class BrowserCacheManager extends CacheManager {
      * Remove an account from the key map
      * @param key
      */
-    removeAccountKeyFromMap(key: string): void {
+    removeAccountKeyFromMap(key: string, correlationId: string): void {
         this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap called");
         this.logger.tracePii(
             `BrowserCacheManager.removeAccountKeyFromMap called with key: ${key}`
@@ -469,10 +552,17 @@ export class BrowserCacheManager extends CacheManager {
         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"
             );
@@ -487,45 +577,79 @@ export class BrowserCacheManager extends CacheManager {
      * Extends inherited removeAccount function to include removal of the account key from the map
      * @param key
      */
-    async removeAccount(key: string): Promise<void> {
-        void super.removeAccount(key);
-        this.removeAccountKeyFromMap(key);
+    async removeAccount(key: string, correlationId: string): Promise<void> {
+        void super.removeAccount(key, correlationId);
+        this.removeAccountKeyFromMap(key, correlationId);
     }
 
     /**
      * Remove account entity from the platform cache if it's outdated
      * @param accountKey
      */
-    removeOutdatedAccount(accountKey: string): void {
+    removeOutdatedAccount(accountKey: string, correlationId: string): void {
         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: string): void {
-        super.removeIdToken(key);
-        this.removeTokenKey(key, CredentialType.ID_TOKEN);
+    removeIdToken(key: string, correlationId: string): void {
+        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: string): Promise<void> {
-        void super.removeAccessToken(key);
-        this.removeTokenKey(key, CredentialType.ACCESS_TOKEN);
+    removeAccessToken(
+        key: string,
+        correlationId: string,
+        updateTokenKeys: boolean = true
+    ): void {
+        super.removeAccessToken(key, correlationId);
+        this.performanceClient?.incrementFields(
+            { accessTokensRemoved: 1 },
+            correlationId
+        );
+        updateTokenKeys &&
+            this.removeTokenKey(
+                key,
+                CredentialType.ACCESS_TOKEN,
+                correlationId
+            );
+    }
+
+    removeAccessTokenKeys(keys: Array<string>, correlationId: string): void {
+        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: string): void {
-        super.removeRefreshToken(key);
-        this.removeTokenKey(key, CredentialType.REFRESH_TOKEN);
+    removeRefreshToken(key: string, correlationId: string): void {
+        super.removeRefreshToken(key, correlationId);
+        this.removeTokenKey(key, CredentialType.REFRESH_TOKEN, correlationId);
     }
 
     /**
@@ -564,12 +688,40 @@ export class BrowserCacheManager extends CacheManager {
         };
     }
 
+    /**
+     * Stores the token keys in the cache
+     * @param tokenKeys
+     * @param correlationId
+     * @returns
+     */
+    setTokenKeys(tokenKeys: TokenKeys, correlationId: string): void {
+        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: string, type: CredentialType): void {
+    addTokenKey(
+        key: string,
+        type: CredentialType,
+        correlationId: string
+    ): void {
         this.logger.trace("BrowserCacheManager addTokenKey called");
         const tokenKeys = this.getTokenKeys();
 
@@ -583,12 +735,16 @@ export 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) {
@@ -607,10 +763,7 @@ export class BrowserCacheManager extends CacheManager {
                 );
         }
 
-        this.setItem(
-            `${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`,
-            JSON.stringify(tokenKeys)
-        );
+        this.setTokenKeys(tokenKeys, correlationId);
     }
 
     /**
@@ -618,9 +771,13 @@ export class BrowserCacheManager extends CacheManager {
      * @param key
      * @param type
      */
-    removeTokenKey(key: string, type: CredentialType): void {
+    removeTokenKey(
+        key: string,
+        type: CredentialType,
+        correlationId: string,
+        tokenKeys: TokenKeys = this.getTokenKeys()
+    ): void {
         this.logger.trace("BrowserCacheManager removeTokenKey called");
-        const tokenKeys = this.getTokenKeys();
 
         switch (type) {
             case CredentialType.ID_TOKEN:
@@ -680,23 +837,23 @@ export class BrowserCacheManager extends CacheManager {
                 );
         }
 
-        this.setItem(
-            `${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`,
-            JSON.stringify(tokenKeys)
-        );
+        this.setTokenKeys(tokenKeys, correlationId);
     }
 
     /**
      * generates idToken entity from a string
      * @param idTokenKey
      */
-    getIdTokenCredential(idTokenKey: string): IdTokenEntity | null {
+    getIdTokenCredential(
+        idTokenKey: string,
+        correlationId: string
+    ): IdTokenEntity | null {
         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;
         }
 
@@ -705,7 +862,6 @@ export class BrowserCacheManager extends CacheManager {
             this.logger.trace(
                 "BrowserCacheManager.getIdTokenCredential: called, no cache hit"
             );
-            this.removeTokenKey(idTokenKey, CredentialType.ID_TOKEN);
             return null;
         }
 
@@ -719,26 +875,34 @@ export class BrowserCacheManager extends CacheManager {
      * set IdToken credential to the platform cache
      * @param idToken
      */
-    setIdTokenCredential(idToken: IdTokenEntity): void {
+    setIdTokenCredential(idToken: IdTokenEntity, correlationId: string): void {
         this.logger.trace("BrowserCacheManager.setIdTokenCredential called");
         const idTokenKey = CacheHelpers.generateCredentialKey(idToken);
+        idToken.lastUpdatedAt = Date.now().toString();
 
-        this.setItem(idTokenKey, JSON.stringify(idToken));
+        this.setItem(idTokenKey, JSON.stringify(idToken), correlationId);
 
-        this.addTokenKey(idTokenKey, CredentialType.ID_TOKEN);
+        this.addTokenKey(idTokenKey, CredentialType.ID_TOKEN, correlationId);
     }
 
     /**
      * generates accessToken entity from a string
      * @param key
      */
-    getAccessTokenCredential(accessTokenKey: string): AccessTokenEntity | null {
+    getAccessTokenCredential(
+        accessTokenKey: string,
+        correlationId: string
+    ): AccessTokenEntity | null {
         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);
@@ -749,7 +913,6 @@ export class BrowserCacheManager extends CacheManager {
             this.logger.trace(
                 "BrowserCacheManager.getAccessTokenCredential: called, no cache hit"
             );
-            this.removeTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN);
             return null;
         }
 
@@ -763,14 +926,27 @@ export class BrowserCacheManager extends CacheManager {
      * set accessToken credential to the platform cache
      * @param accessToken
      */
-    setAccessTokenCredential(accessToken: AccessTokenEntity): void {
+    setAccessTokenCredential(
+        accessToken: AccessTokenEntity,
+        correlationId: string
+    ): void {
         this.logger.trace(
             "BrowserCacheManager.setAccessTokenCredential called"
         );
         const accessTokenKey = CacheHelpers.generateCredentialKey(accessToken);
-        this.setItem(accessTokenKey, JSON.stringify(accessToken));
+        accessToken.lastUpdatedAt = Date.now().toString();
 
-        this.addTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN);
+        this.setItem(
+            accessTokenKey,
+            JSON.stringify(accessToken),
+            correlationId
+        );
+
+        this.addTokenKey(
+            accessTokenKey,
+            CredentialType.ACCESS_TOKEN,
+            correlationId
+        );
     }
 
     /**
@@ -778,14 +954,19 @@ export class BrowserCacheManager extends CacheManager {
      * @param refreshTokenKey
      */
     getRefreshTokenCredential(
-        refreshTokenKey: string
+        refreshTokenKey: string,
+        correlationId: string
     ): RefreshTokenEntity | null {
         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);
@@ -796,7 +977,6 @@ export class BrowserCacheManager extends CacheManager {
             this.logger.trace(
                 "BrowserCacheManager.getRefreshTokenCredential: called, no cache hit"
             );
-            this.removeTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN);
             return null;
         }
 
@@ -810,15 +990,28 @@ export class BrowserCacheManager extends CacheManager {
      * set refreshToken credential to the platform cache
      * @param refreshToken
      */
-    setRefreshTokenCredential(refreshToken: RefreshTokenEntity): void {
+    setRefreshTokenCredential(
+        refreshToken: RefreshTokenEntity,
+        correlationId: string
+    ): void {
         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
+        );
     }
 
     /**
@@ -853,10 +1046,17 @@ export class BrowserCacheManager extends CacheManager {
      * set appMetadata entity to the platform cache
      * @param appMetadata
      */
-    setAppMetadata(appMetadata: AppMetadataEntity): void {
+    setAppMetadata(
+        appMetadata: AppMetadataEntity,
+        correlationId: string
+    ): void {
         this.logger.trace("BrowserCacheManager.setAppMetadata called");
         const appMetadataKey = CacheHelpers.generateAppMetadataKey(appMetadata);
-        this.setItem(appMetadataKey, JSON.stringify(appMetadata));
+        this.setItem(
+            appMetadataKey,
+            JSON.stringify(appMetadata),
+            correlationId
+        );
     }
 
     /**
@@ -898,10 +1098,15 @@ export class BrowserCacheManager extends CacheManager {
      */
     setServerTelemetry(
         serverTelemetryKey: string,
-        serverTelemetry: ServerTelemetryEntity
+        serverTelemetry: ServerTelemetryEntity,
+        correlationId: string
     ): void {
         this.logger.trace("BrowserCacheManager.setServerTelemetry called");
-        this.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry));
+        this.setItem(
+            serverTelemetryKey,
+            JSON.stringify(serverTelemetry),
+            correlationId
+        );
     }
 
     /**
@@ -976,7 +1181,7 @@ export class BrowserCacheManager extends CacheManager {
     /**
      * Gets the active account
      */
-    getActiveAccount(): AccountInfo | null {
+    getActiveAccount(correlationId: string): AccountInfo | null {
         const activeAccountKeyFilters = this.generateCacheKey(
             PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS
         );
@@ -996,9 +1201,12 @@ export class BrowserCacheManager extends CacheManager {
                 );
                 return null;
             }
-            const activeAccount = this.getAccountInfoFilteredBy({
-                localAccountId: activeAccountValueLocal,
-            });
+            const activeAccount = this.getAccountInfoFilteredBy(
+                {
+                    localAccountId: activeAccountValueLocal,
+                },
+                correlationId
+            );
             if (activeAccount) {
                 this.logger.trace(
                     "BrowserCacheManager.getActiveAccount: Legacy active account cache schema found"
@@ -1006,7 +1214,7 @@ export class BrowserCacheManager extends CacheManager {
                 this.logger.trace(
                     "BrowserCacheManager.getActiveAccount: Adding active account filters cache schema"
                 );
-                this.setActiveAccount(activeAccount);
+                this.setActiveAccount(activeAccount, correlationId);
                 return activeAccount;
             }
             return null;
@@ -1018,11 +1226,14 @@ export class BrowserCacheManager extends CacheManager {
             this.logger.trace(
                 "BrowserCacheManager.getActiveAccount: Active account filters schema found"
             );
-            return this.getAccountInfoFilteredBy({
-                homeAccountId: activeAccountValueObj.homeAccountId,
-                localAccountId: activeAccountValueObj.localAccountId,
-                tenantId: activeAccountValueObj.tenantId,
-            });
+            return this.getAccountInfoFilteredBy(
+                {
+                    homeAccountId: activeAccountValueObj.homeAccountId,
+                    localAccountId: activeAccountValueObj.localAccountId,
+                    tenantId: activeAccountValueObj.tenantId,
+                },
+                correlationId
+            );
         }
         this.logger.trace(
             "BrowserCacheManager.getActiveAccount: No active account found"
@@ -1034,7 +1245,7 @@ export class BrowserCacheManager extends CacheManager {
      * Sets the active account's localAccountId in cache
      * @param account
      */
-    setActiveAccount(account: AccountInfo | null): void {
+    setActiveAccount(account: AccountInfo | null, correlationId: string): void {
         const activeAccountKey = this.generateCacheKey(
             PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS
         );
@@ -1047,14 +1258,17 @@ export class BrowserCacheManager extends CacheManager {
                 homeAccountId: account.homeAccountId,
                 localAccountId: account.localAccountId,
                 tenantId: account.tenantId,
+                lastUpdatedAt: Date.now().toString(),
             };
-            this.browserStorage.setItem(
+            this.setItem(
                 activeAccountKey,
-                JSON.stringify(activeAccountValue)
+                JSON.stringify(activeAccountValue),
+                correlationId
             );
-            this.browserStorage.setItem(
+            this.setItem(
                 activeAccountKeyLocal,
-                account.localAccountId
+                account.localAccountId,
+                correlationId
             );
         } else {
             this.logger.verbose(
@@ -1103,10 +1317,15 @@ export class BrowserCacheManager extends CacheManager {
      */
     setThrottlingCache(
         throttlingCacheKey: string,
-        throttlingCache: ThrottlingEntity
+        throttlingCache: ThrottlingEntity,
+        correlationId: string
     ): void {
         this.logger.trace("BrowserCacheManager.setThrottlingCache called");
-        this.setItem(throttlingCacheKey, JSON.stringify(throttlingCache));
+        this.setItem(
+            throttlingCacheKey,
+            JSON.stringify(throttlingCache),
+            correlationId
+        );
     }
 
     /**
@@ -1213,10 +1432,10 @@ export class BrowserCacheManager extends CacheManager {
     /**
      * Clears all cache entries created by MSAL.
      */
-    async clear(): Promise<void> {
+    async clear(correlationId: string): Promise<void> {
         // 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: string) => {
@@ -1258,23 +1477,26 @@ export class BrowserCacheManager extends CacheManager {
 
         const tokenKeys = this.getTokenKeys();
 
-        const removedAccessTokens: Array<Promise<void>> = [];
+        let removedAccessTokens: number = 0;
         tokenKeys.accessToken.forEach((key: string) => {
             // 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) {
+        if (removedAccessTokens > 0) {
             this.logger.warning(
-                `${removedAccessTokens.length} access tokens with claims in the cache keys have been removed from the cache.`
+                `${removedAccessTokens} access tokens with claims in the cache keys have been removed from the cache.`
             );
         }
     }
@@ -1678,7 +1900,8 @@ export class BrowserCacheManager extends CacheManager {
      */
     updateCredentialCacheKey(
         currentCacheKey: string,
-        credential: ValidCredentialType
+        credential: ValidCredentialType,
+        correlationId: string
     ): string {
         const updatedCacheKey = CacheHelpers.generateCredentialKey(credential);
 
@@ -1686,7 +1909,7 @@ export class BrowserCacheManager extends CacheManager {
             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`
                 );
@@ -1757,7 +1980,7 @@ export class BrowserCacheManager extends CacheManager {
             idToken: idTokenEntity,
             accessToken: accessTokenEntity,
         };
-        return this.saveCacheRecord(cacheRecord);
+        return this.saveCacheRecord(cacheRecord, result.correlationId);
     }
 
     /**
@@ -1768,14 +1991,14 @@ export class BrowserCacheManager extends CacheManager {
      */
     async saveCacheRecord(
         cacheRecord: CacheRecord,
-        storeInCache?: StoreInCache,
-        correlationId?: string
+        correlationId: string,
+        storeInCache?: StoreInCache
     ): Promise<void> {
         try {
             await super.saveCacheRecord(
                 cacheRecord,
-                storeInCache,
-                correlationId
+                correlationId,
+                storeInCache
             );
         } catch (e) {
             if (