@azure/msal-browser 4.24.1 → 5.0.0-alpha.0

package/src/cache/BrowserCacheManager.ts

@@ -6,10 +6,10 @@
 import {
     AccessTokenEntity,
     AccountEntity,
+    AccountEntityUtils,
     AccountInfo,
     ActiveAccountFilters,
     AppMetadataEntity,
-    AuthenticationScheme,
     AuthorityMetadataEntity,
     CacheError,
     CacheErrorCodes,
@@ -26,7 +26,6 @@ import {
     IPerformanceClient,
     Logger,
     PerformanceEvents,
-    PersistentCacheKeys,
     RefreshTokenEntity,
     ServerTelemetryEntity,
     StaticAuthorityOptions,
@@ -36,8 +35,6 @@ import {
     TimeUtils,
     TokenKeys,
     CredentialEntity,
-    CredentialType,
-    DEFAULT_TOKEN_RENEWAL_OFFSET_SEC,
 } from "@azure/msal-common/browser";
 import { CacheOptions } from "../config/Configuration.js";
 import {
@@ -74,8 +71,6 @@ import { EncryptedData, isEncrypted } from "./EncryptedData.js";
 
 /**
  * This class implements the cache storage interface for MSAL through browser local or session storage.
- * Cookies are only used if storeAuthStateInCookie is true, and are only used for
- * parameters such as state and nonce, generally.
  */
 export class BrowserCacheManager extends CacheManager {
     // Cache configuration, either set by user or default values.
@@ -120,11 +115,12 @@ export class BrowserCacheManager extends CacheManager {
         );
         this.temporaryCacheStorage = getStorageImplementation(
             clientId,
-            cacheConfig.temporaryCacheLocation,
+            BrowserCacheLocation.SessionStorage,
             logger,
             performanceClient
         );
         this.cookieStorage = new CookieStorage();
+
         this.eventHandler = eventHandler;
     }
 
@@ -271,7 +267,7 @@ export class BrowserCacheManager extends CacheManager {
                 (expirationTime &&
                     TimeUtils.isTokenExpired(
                         expirationTime,
-                        DEFAULT_TOKEN_RENEWAL_OFFSET_SEC
+                        Constants.DEFAULT_TOKEN_RENEWAL_OFFSET_SEC
                     ))
             ) {
                 this.browserStorage.removeItem(v0Key);
@@ -350,7 +346,8 @@ export class BrowserCacheManager extends CacheManager {
         );
         if (previousVersion) {
             this.logger.info(
-                `MSAL.js was last initialized by version: ${previousVersion}`
+                `MSAL.js was last initialized by version: '${previousVersion}'`,
+                correlationId
             );
             this.performanceClient.addFields(
                 { previousLibraryVersion: previousVersion },
@@ -481,7 +478,8 @@ export class BrowserCacheManager extends CacheManager {
                     this.browserStorage.setUserData.bind(this.browserStorage),
                     PerformanceEvents.SetUserData,
                     this.logger,
-                    this.performanceClient
+                    this.performanceClient,
+                    correlationId
                 )(key, value, correlationId, timestamp);
                 if (i > 0) {
                     // Finally update the token keys array with the tokens removed
@@ -545,7 +543,10 @@ export class BrowserCacheManager extends CacheManager {
         accountKey: string,
         correlationId: string
     ): AccountEntity | null {
-        this.logger.trace("BrowserCacheManager.getAccount called");
+        this.logger.trace(
+            "BrowserCacheManager.getAccount called",
+            correlationId
+        );
         const serializedAccount = this.browserStorage.getUserData(accountKey);
         if (!serializedAccount) {
             this.removeAccountKeyFromMap(accountKey, correlationId);
@@ -553,12 +554,15 @@ export class BrowserCacheManager extends CacheManager {
         }
 
         const parsedAccount = this.validateAndParseJson(serializedAccount);
-        if (!parsedAccount || !AccountEntity.isAccountEntity(parsedAccount)) {
+        if (
+            !parsedAccount ||
+            !AccountEntityUtils.isAccountEntity(parsedAccount)
+        ) {
             return null;
         }
 
         return CacheManager.toObject<AccountEntity>(
-            new AccountEntity(),
+            {} as AccountEntity,
             parsedAccount
         );
     }
@@ -571,8 +575,13 @@ export class BrowserCacheManager extends CacheManager {
         account: AccountEntity,
         correlationId: string
     ): Promise<void> {
-        this.logger.trace("BrowserCacheManager.setAccount called");
-        const key = this.generateAccountKey(account.getAccountInfo());
+        this.logger.trace(
+            "BrowserCacheManager.setAccount called",
+            correlationId
+        );
+        const key = this.generateAccountKey(
+            AccountEntityUtils.getAccountInfo(account)
+        );
         const timestamp = Date.now().toString();
         account.lastUpdatedAt = timestamp;
         await this.setUserData(
@@ -581,22 +590,7 @@ export class BrowserCacheManager extends CacheManager {
             correlationId,
             timestamp
         );
-        const wasAdded = this.addAccountKeyToMap(key, correlationId);
-
-        /**
-         * @deprecated - Remove this in next major version in favor of more consistent LOGIN event
-         */
-        if (
-            this.cacheConfig.cacheLocation ===
-                BrowserCacheLocation.LocalStorage &&
-            wasAdded
-        ) {
-            this.eventHandler.emitEvent(
-                EventType.ACCOUNT_ADDED,
-                undefined,
-                account.getAccountInfo()
-            );
-        }
+        this.addAccountKeyToMap(key, correlationId);
     }
 
     /**
@@ -612,9 +606,13 @@ export class BrowserCacheManager extends CacheManager {
      * @param key
      */
     addAccountKeyToMap(key: string, correlationId: string): boolean {
-        this.logger.trace("BrowserCacheManager.addAccountKeyToMap called");
+        this.logger.trace(
+            "BrowserCacheManager.addAccountKeyToMap called",
+            correlationId
+        );
         this.logger.tracePii(
-            `BrowserCacheManager.addAccountKeyToMap called with key: ${key}`
+            `BrowserCacheManager.addAccountKeyToMap called with key: '${key}'`,
+            correlationId
         );
         const accountKeys = this.getAccountKeys();
         if (accountKeys.indexOf(key) === -1) {
@@ -626,12 +624,14 @@ export class BrowserCacheManager extends CacheManager {
                 correlationId
             );
             this.logger.verbose(
-                "BrowserCacheManager.addAccountKeyToMap account key added"
+                "BrowserCacheManager.addAccountKeyToMap account key added",
+                correlationId
             );
             return true;
         } else {
             this.logger.verbose(
-                "BrowserCacheManager.addAccountKeyToMap account key already exists in map"
+                "BrowserCacheManager.addAccountKeyToMap account key already exists in map",
+                correlationId
             );
             return false;
         }
@@ -642,9 +642,13 @@ export class BrowserCacheManager extends CacheManager {
      * @param key
      */
     removeAccountKeyFromMap(key: string, correlationId: string): void {
-        this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap called");
+        this.logger.trace(
+            "BrowserCacheManager.removeAccountKeyFromMap called",
+            correlationId
+        );
         this.logger.tracePii(
-            `BrowserCacheManager.removeAccountKeyFromMap called with key: ${key}`
+            `BrowserCacheManager.removeAccountKeyFromMap called with key: '${key}'`,
+            correlationId
         );
         const accountKeys = this.getAccountKeys();
         const removalIndex = accountKeys.indexOf(key);
@@ -662,11 +666,13 @@ export class BrowserCacheManager extends CacheManager {
                 );
             }
             this.logger.trace(
-                "BrowserCacheManager.removeAccountKeyFromMap account key removed"
+                "BrowserCacheManager.removeAccountKeyFromMap account key removed",
+                correlationId
             );
         } else {
             this.logger.trace(
-                "BrowserCacheManager.removeAccountKeyFromMap key not found in existing map"
+                "BrowserCacheManager.removeAccountKeyFromMap key not found in existing map",
+                correlationId
             );
         }
     }
@@ -699,19 +705,6 @@ export class BrowserCacheManager extends CacheManager {
                 this.browserStorage.removeItem(key);
             }
         });
-
-        /**
-         * @deprecated - Remove this in next major version in favor of more consistent LOGOUT event
-         */
-        if (
-            this.cacheConfig.cacheLocation === BrowserCacheLocation.LocalStorage
-        ) {
-            this.eventHandler.emitEvent(
-                EventType.ACCOUNT_REMOVED,
-                undefined,
-                account
-            );
-        }
     }
 
     /**
@@ -723,7 +716,10 @@ export class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         const idRemoval = tokenKeys.idToken.indexOf(key);
         if (idRemoval > -1) {
-            this.logger.info("idToken removed from tokenKeys map");
+            this.logger.info(
+                "idToken removed from tokenKeys map",
+                correlationId
+            );
             tokenKeys.idToken.splice(idRemoval, 1);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -753,7 +749,7 @@ export class BrowserCacheManager extends CacheManager {
         correlationId: string,
         schemaVersion: number = CacheKeys.CREDENTIAL_SCHEMA_VERSION
     ): void {
-        this.logger.trace("removeAccessTokenKey called");
+        this.logger.trace("removeAccessTokenKey called", correlationId);
         const tokenKeys = this.getTokenKeys(schemaVersion);
         let keysRemoved = 0;
         keys.forEach((key) => {
@@ -766,7 +762,8 @@ export class BrowserCacheManager extends CacheManager {
 
         if (keysRemoved > 0) {
             this.logger.info(
-                `removed ${keysRemoved} accessToken keys from tokenKeys map`
+                `removed '${keysRemoved}' accessToken keys from tokenKeys map`,
+                correlationId
             );
             this.setTokenKeys(tokenKeys, correlationId, schemaVersion);
             return;
@@ -782,7 +779,10 @@ export class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         const refreshRemoval = tokenKeys.refreshToken.indexOf(key);
         if (refreshRemoval > -1) {
-            this.logger.info("refreshToken removed from tokenKeys map");
+            this.logger.info(
+                "refreshToken removed from tokenKeys map",
+                correlationId
+            );
             tokenKeys.refreshToken.splice(refreshRemoval, 1);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -799,7 +799,7 @@ export class BrowserCacheManager extends CacheManager {
     }
 
     /**
-     * Stores the token keys in the cache
+     * Sets the token keys in the cache
      * @param tokenKeys
      * @param correlationId
      * @returns
@@ -839,7 +839,8 @@ export class BrowserCacheManager extends CacheManager {
         const value = this.browserStorage.getUserData(idTokenKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getIdTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getIdTokenCredential: called, no cache hit",
+                correlationId
             );
             this.removeIdToken(idTokenKey, correlationId);
             return null;
@@ -848,13 +849,15 @@ export class BrowserCacheManager extends CacheManager {
         const parsedIdToken = this.validateAndParseJson(value);
         if (!parsedIdToken || !CacheHelpers.isIdTokenEntity(parsedIdToken)) {
             this.logger.trace(
-                "BrowserCacheManager.getIdTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getIdTokenCredential: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
         this.logger.trace(
-            "BrowserCacheManager.getIdTokenCredential: cache hit"
+            "BrowserCacheManager.getIdTokenCredential: cache hit",
+            correlationId
         );
         return parsedIdToken as IdTokenEntity;
     }
@@ -867,7 +870,10 @@ export class BrowserCacheManager extends CacheManager {
         idToken: IdTokenEntity,
         correlationId: string
     ): Promise<void> {
-        this.logger.trace("BrowserCacheManager.setIdTokenCredential called");
+        this.logger.trace(
+            "BrowserCacheManager.setIdTokenCredential called",
+            correlationId
+        );
         const idTokenKey = this.generateCredentialKey(idToken);
         const timestamp = Date.now().toString();
         idToken.lastUpdatedAt = timestamp;
@@ -882,7 +888,8 @@ export class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         if (tokenKeys.idToken.indexOf(idTokenKey) === -1) {
             this.logger.info(
-                "BrowserCacheManager: addTokenKey - idToken added to map"
+                "BrowserCacheManager: addTokenKey - idToken added to map",
+                correlationId
             );
             tokenKeys.idToken.push(idTokenKey);
             this.setTokenKeys(tokenKeys, correlationId);
@@ -900,7 +907,8 @@ export class BrowserCacheManager extends CacheManager {
         const value = this.browserStorage.getUserData(accessTokenKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getAccessTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getAccessTokenCredential: called, no cache hit",
+                correlationId
             );
             this.removeAccessTokenKeys([accessTokenKey], correlationId);
             return null;
@@ -911,13 +919,15 @@ export class BrowserCacheManager extends CacheManager {
             !CacheHelpers.isAccessTokenEntity(parsedAccessToken)
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getAccessTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getAccessTokenCredential: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
         this.logger.trace(
-            "BrowserCacheManager.getAccessTokenCredential: cache hit"
+            "BrowserCacheManager.getAccessTokenCredential: cache hit",
+            correlationId
         );
         return parsedAccessToken as AccessTokenEntity;
     }
@@ -931,7 +941,8 @@ export class BrowserCacheManager extends CacheManager {
         correlationId: string
     ): Promise<void> {
         this.logger.trace(
-            "BrowserCacheManager.setAccessTokenCredential called"
+            "BrowserCacheManager.setAccessTokenCredential called",
+            correlationId
         );
         const accessTokenKey = this.generateCredentialKey(accessToken);
         const timestamp = Date.now().toString();
@@ -950,7 +961,8 @@ export class BrowserCacheManager extends CacheManager {
             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`
+            `access token '${index === -1 ? "added to" : "updated in"}' map`,
+            correlationId
         );
         tokenKeys.accessToken.push(accessTokenKey);
         this.setTokenKeys(tokenKeys, correlationId);
@@ -967,7 +979,8 @@ export class BrowserCacheManager extends CacheManager {
         const value = this.browserStorage.getUserData(refreshTokenKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getRefreshTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getRefreshTokenCredential: called, no cache hit",
+                correlationId
             );
             this.removeRefreshToken(refreshTokenKey, correlationId);
             return null;
@@ -978,13 +991,15 @@ export class BrowserCacheManager extends CacheManager {
             !CacheHelpers.isRefreshTokenEntity(parsedRefreshToken)
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getRefreshTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getRefreshTokenCredential: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
         this.logger.trace(
-            "BrowserCacheManager.getRefreshTokenCredential: cache hit"
+            "BrowserCacheManager.getRefreshTokenCredential: cache hit",
+            correlationId
         );
         return parsedRefreshToken as RefreshTokenEntity;
     }
@@ -998,7 +1013,8 @@ export class BrowserCacheManager extends CacheManager {
         correlationId: string
     ): Promise<void> {
         this.logger.trace(
-            "BrowserCacheManager.setRefreshTokenCredential called"
+            "BrowserCacheManager.setRefreshTokenCredential called",
+            correlationId
         );
         const refreshTokenKey = this.generateCredentialKey(refreshToken);
         const timestamp = Date.now().toString();
@@ -1014,7 +1030,8 @@ export class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         if (tokenKeys.refreshToken.indexOf(refreshTokenKey) === -1) {
             this.logger.info(
-                "BrowserCacheManager: addTokenKey - refreshToken added to map"
+                "BrowserCacheManager: addTokenKey - refreshToken added to map",
+                correlationId
             );
             tokenKeys.refreshToken.push(refreshTokenKey);
             this.setTokenKeys(tokenKeys, correlationId);
@@ -1024,12 +1041,17 @@ export class BrowserCacheManager extends CacheManager {
     /**
      * fetch appMetadata entity from the platform cache
      * @param appMetadataKey
+     * @param correlationId
      */
-    getAppMetadata(appMetadataKey: string): AppMetadataEntity | null {
+    getAppMetadata(
+        appMetadataKey: string,
+        correlationId: string
+    ): AppMetadataEntity | null {
         const value = this.browserStorage.getItem(appMetadataKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getAppMetadata: called, no cache hit"
+                "BrowserCacheManager.getAppMetadata: called, no cache hit",
+                correlationId
             );
             return null;
         }
@@ -1040,24 +1062,32 @@ export class BrowserCacheManager extends CacheManager {
             !CacheHelpers.isAppMetadataEntity(appMetadataKey, parsedMetadata)
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getAppMetadata: called, no cache hit"
+                "BrowserCacheManager.getAppMetadata: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
-        this.logger.trace("BrowserCacheManager.getAppMetadata: cache hit");
+        this.logger.trace(
+            "BrowserCacheManager.getAppMetadata: cache hit",
+            correlationId
+        );
         return parsedMetadata as AppMetadataEntity;
     }
 
     /**
      * set appMetadata entity to the platform cache
      * @param appMetadata
+     * @param correlationId
      */
     setAppMetadata(
         appMetadata: AppMetadataEntity,
         correlationId: string
     ): void {
-        this.logger.trace("BrowserCacheManager.setAppMetadata called");
+        this.logger.trace(
+            "BrowserCacheManager.setAppMetadata called",
+            correlationId
+        );
         const appMetadataKey = CacheHelpers.generateAppMetadataKey(appMetadata);
         this.setItem(
             appMetadataKey,
@@ -1069,14 +1099,17 @@ export class BrowserCacheManager extends CacheManager {
     /**
      * fetch server telemetry entity from the platform cache
      * @param serverTelemetryKey
+     * @param correlationId
      */
     getServerTelemetry(
-        serverTelemetryKey: string
+        serverTelemetryKey: string,
+        correlationId: string
     ): ServerTelemetryEntity | null {
         const value = this.browserStorage.getItem(serverTelemetryKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getServerTelemetry: called, no cache hit"
+                "BrowserCacheManager.getServerTelemetry: called, no cache hit",
+                correlationId
             );
             return null;
         }
@@ -1089,12 +1122,16 @@ export class BrowserCacheManager extends CacheManager {
             )
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getServerTelemetry: called, no cache hit"
+                "BrowserCacheManager.getServerTelemetry: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
-        this.logger.trace("BrowserCacheManager.getServerTelemetry: cache hit");
+        this.logger.trace(
+            "BrowserCacheManager.getServerTelemetry: cache hit",
+            correlationId
+        );
         return parsedEntity as ServerTelemetryEntity;
     }
 
@@ -1108,7 +1145,10 @@ export class BrowserCacheManager extends CacheManager {
         serverTelemetry: ServerTelemetryEntity,
         correlationId: string
     ): void {
-        this.logger.trace("BrowserCacheManager.setServerTelemetry called");
+        this.logger.trace(
+            "BrowserCacheManager.setServerTelemetry called",
+            correlationId
+        );
         this.setItem(
             serverTelemetryKey,
             JSON.stringify(serverTelemetry),
@@ -1119,11 +1159,15 @@ export class BrowserCacheManager extends CacheManager {
     /**
      *
      */
-    getAuthorityMetadata(key: string): AuthorityMetadataEntity | null {
+    getAuthorityMetadata(
+        key: string,
+        correlationId: string
+    ): AuthorityMetadataEntity | null {
         const value = this.internalStorage.getItem(key);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getAuthorityMetadata: called, no cache hit"
+                "BrowserCacheManager.getAuthorityMetadata: called, no cache hit",
+                correlationId
             );
             return null;
         }
@@ -1133,7 +1177,8 @@ export class BrowserCacheManager extends CacheManager {
             CacheHelpers.isAuthorityMetadataEntity(key, parsedMetadata)
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getAuthorityMetadata: cache hit"
+                "BrowserCacheManager.getAuthorityMetadata: cache hit",
+                correlationId
             );
             return parsedMetadata as AuthorityMetadataEntity;
         }
@@ -1168,20 +1213,27 @@ export class BrowserCacheManager extends CacheManager {
      */
     getWrapperMetadata(): [string, string] {
         const sku =
-            this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_SKU) ||
-            Constants.EMPTY_STRING;
+            this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_SKU) || "";
         const version =
-            this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_VER) ||
-            Constants.EMPTY_STRING;
+            this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_VER) || "";
         return [sku, version];
     }
 
     /**
      *
+     * @param key
      * @param entity
+     * @param correlationId
      */
-    setAuthorityMetadata(key: string, entity: AuthorityMetadataEntity): void {
-        this.logger.trace("BrowserCacheManager.setAuthorityMetadata called");
+    setAuthorityMetadata(
+        key: string,
+        entity: AuthorityMetadataEntity,
+        correlationId: string
+    ): void {
+        this.logger.trace(
+            "BrowserCacheManager.setAuthorityMetadata called",
+            correlationId
+        );
         this.internalStorage.setItem(key, JSON.stringify(entity));
     }
 
@@ -1190,14 +1242,15 @@ export class BrowserCacheManager extends CacheManager {
      */
     getActiveAccount(correlationId: string): AccountInfo | null {
         const activeAccountKeyFilters = this.generateCacheKey(
-            PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS
+            Constants.PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS
         );
         const activeAccountValueFilters = this.browserStorage.getItem(
             activeAccountKeyFilters
         );
         if (!activeAccountValueFilters) {
             this.logger.trace(
-                "BrowserCacheManager.getActiveAccount: No active account filters found"
+                "BrowserCacheManager.getActiveAccount: No active account filters found",
+                correlationId
             );
             return null;
         }
@@ -1206,7 +1259,8 @@ export class BrowserCacheManager extends CacheManager {
         ) as AccountInfo;
         if (activeAccountValueObj) {
             this.logger.trace(
-                "BrowserCacheManager.getActiveAccount: Active account filters schema found"
+                "BrowserCacheManager.getActiveAccount: Active account filters schema found",
+                correlationId
             );
             return this.getAccountInfoFilteredBy(
                 {
@@ -1218,7 +1272,8 @@ export class BrowserCacheManager extends CacheManager {
             );
         }
         this.logger.trace(
-            "BrowserCacheManager.getActiveAccount: No active account found"
+            "BrowserCacheManager.getActiveAccount: No active account found",
+            correlationId
         );
         return null;
     }
@@ -1229,15 +1284,17 @@ export class BrowserCacheManager extends CacheManager {
      */
     setActiveAccount(account: AccountInfo | null, correlationId: string): void {
         const activeAccountKey = this.generateCacheKey(
-            PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS
+            Constants.PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS
         );
         if (account) {
-            this.logger.verbose("setActiveAccount: Active account set");
+            this.logger.verbose(
+                "setActiveAccount: Active account set",
+                correlationId
+            );
             const activeAccountValue: ActiveAccountFilters = {
                 homeAccountId: account.homeAccountId,
                 localAccountId: account.localAccountId,
                 tenantId: account.tenantId,
-                lastUpdatedAt: TimeUtils.nowSeconds().toString(),
             };
             this.setItem(
                 activeAccountKey,
@@ -1246,7 +1303,8 @@ export class BrowserCacheManager extends CacheManager {
             );
         } else {
             this.logger.verbose(
-                "setActiveAccount: No account passed, active account not set"
+                "setActiveAccount: No account passed, active account not set",
+                correlationId
             );
             this.browserStorage.removeItem(activeAccountKey);
         }
@@ -1256,12 +1314,17 @@ export class BrowserCacheManager extends CacheManager {
     /**
      * fetch throttling entity from the platform cache
      * @param throttlingCacheKey
+     * @param correlationId
      */
-    getThrottlingCache(throttlingCacheKey: string): ThrottlingEntity | null {
+    getThrottlingCache(
+        throttlingCacheKey: string,
+        correlationId: string
+    ): ThrottlingEntity | null {
         const value = this.browserStorage.getItem(throttlingCacheKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getThrottlingCache: called, no cache hit"
+                "BrowserCacheManager.getThrottlingCache: called, no cache hit",
+                correlationId
             );
             return null;
         }
@@ -1275,12 +1338,16 @@ export class BrowserCacheManager extends CacheManager {
             )
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getThrottlingCache: called, no cache hit"
+                "BrowserCacheManager.getThrottlingCache: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
-        this.logger.trace("BrowserCacheManager.getThrottlingCache: cache hit");
+        this.logger.trace(
+            "BrowserCacheManager.getThrottlingCache: cache hit",
+            correlationId
+        );
         return parsedThrottlingCache as ThrottlingEntity;
     }
 
@@ -1294,7 +1361,10 @@ export class BrowserCacheManager extends CacheManager {
         throttlingCache: ThrottlingEntity,
         correlationId: string
     ): void {
-        this.logger.trace("BrowserCacheManager.setThrottlingCache called");
+        this.logger.trace(
+            "BrowserCacheManager.setThrottlingCache called",
+            correlationId
+        );
         this.setItem(
             throttlingCacheKey,
             JSON.stringify(throttlingCache),
@@ -1304,21 +1374,16 @@ export class BrowserCacheManager extends CacheManager {
 
     /**
      * Gets cache item with given key.
-     * Will retrieve from cookies if storeAuthStateInCookie is set to true.
-     * @param key
+     * @param cacheKey
+     * @param correlationId
+     * @param generateKey
      */
-    getTemporaryCache(cacheKey: string, generateKey?: boolean): string | null {
+    getTemporaryCache(
+        cacheKey: string,
+        correlationId: string,
+        generateKey?: boolean
+    ): string | null {
         const key = generateKey ? this.generateCacheKey(cacheKey) : cacheKey;
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            const itemCookie = this.cookieStorage.getItem(key);
-            if (itemCookie) {
-                this.logger.trace(
-                    "BrowserCacheManager.getTemporaryCache: storeAuthStateInCookies set to true, retrieving from cookies"
-                );
-                return itemCookie;
-            }
-        }
-
         const value = this.temporaryCacheStorage.getItem(key);
         if (!value) {
             // If temp cache item not found in session/memory, check local storage for items set by old versions
@@ -1329,26 +1394,23 @@ export class BrowserCacheManager extends CacheManager {
                 const item = this.browserStorage.getItem(key);
                 if (item) {
                     this.logger.trace(
-                        "BrowserCacheManager.getTemporaryCache: Temporary cache item found in local storage"
+                        "BrowserCacheManager.getTemporaryCache: Temporary cache item found in local storage",
+                        correlationId
                     );
                     return item;
                 }
             }
             this.logger.trace(
-                "BrowserCacheManager.getTemporaryCache: No cache item found in local storage"
+                "BrowserCacheManager.getTemporaryCache: No cache item found in local storage",
+                correlationId
             );
             return null;
         }
-        this.logger.trace(
-            "BrowserCacheManager.getTemporaryCache: Temporary cache item returned"
-        );
         return value;
     }
 
     /**
      * Sets the cache item with the key and value given.
-     * Stores in cookie if storeAuthStateInCookie is set to true.
-     * This can cause cookie overflow if used incorrectly.
      * @param key
      * @param value
      */
@@ -1358,19 +1420,7 @@ export class BrowserCacheManager extends CacheManager {
         generateKey?: boolean
     ): void {
         const key = generateKey ? this.generateCacheKey(cacheKey) : cacheKey;
-
         this.temporaryCacheStorage.setItem(key, value);
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            this.logger.trace(
-                "BrowserCacheManager.setTemporaryCache: storeAuthStateInCookie set to true, setting item cookie"
-            );
-            this.cookieStorage.setItem(
-                key,
-                value,
-                undefined,
-                this.cacheConfig.secureCookies
-            );
-        }
     }
 
     /**
@@ -1383,17 +1433,10 @@ export class BrowserCacheManager extends CacheManager {
 
     /**
      * Removes the temporary cache item with the given key.
-     * Will also clear the cookie item if storeAuthStateInCookie is set to true.
      * @param key
      */
     removeTemporaryItem(key: string): void {
         this.temporaryCacheStorage.removeItem(key);
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            this.logger.trace(
-                "BrowserCacheManager.removeItem: storeAuthStateInCookie is true, clearing item cookie"
-            );
-            this.cookieStorage.removeItem(key);
-        }
     }
 
     /**
@@ -1434,43 +1477,6 @@ export class BrowserCacheManager extends CacheManager {
         this.internalStorage.clear();
     }
 
-    /**
-     * Clears all access tokes that have claims prior to saving the current one
-     * @param performanceClient {IPerformanceClient}
-     * @param correlationId {string} correlation id
-     * @returns
-     */
-    clearTokensAndKeysWithClaims(correlationId: string): void {
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.ClearTokensAndKeysWithClaims,
-            correlationId
-        );
-
-        const tokenKeys = this.getTokenKeys();
-        let removedAccessTokens = 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,
-                correlationId
-            );
-            if (
-                credential?.requestedClaimsHash &&
-                key.includes(credential.requestedClaimsHash.toLowerCase())
-            ) {
-                this.removeAccessToken(key, correlationId);
-                removedAccessTokens++;
-            }
-        });
-
-        // warn if any access tokens are removed
-        if (removedAccessTokens > 0) {
-            this.logger.warning(
-                `${removedAccessTokens} access tokens with claims in the cache keys have been removed from the cache.`
-            );
-        }
-    }
-
     /**
      * Prepend msal.<client-id> to each key
      * @param key
@@ -1493,13 +1499,14 @@ export class BrowserCacheManager extends CacheManager {
      */
     generateCredentialKey(credential: CredentialEntity): string {
         const familyId =
-            (credential.credentialType === CredentialType.REFRESH_TOKEN &&
+            (credential.credentialType ===
+                Constants.CredentialType.REFRESH_TOKEN &&
                 credential.familyId) ||
             credential.clientId;
         const scheme =
             credential.tokenType &&
             credential.tokenType.toLowerCase() !==
-                AuthenticationScheme.BEARER.toLowerCase()
+                Constants.AuthenticationScheme.BEARER.toLowerCase()
                 ? credential.tokenType.toLowerCase()
                 : "";
         const credentialKey = [
@@ -1510,7 +1517,6 @@ export class BrowserCacheManager extends CacheManager {
             familyId,
             credential.realm || "",
             credential.target || "",
-            credential.requestedClaimsHash || "",
             scheme,
         ];
 
@@ -1536,10 +1542,13 @@ export class BrowserCacheManager extends CacheManager {
 
     /**
      * Reset all temporary cache items
-     * @param state
+     * @param correlationId
      */
-    resetRequestCache(): void {
-        this.logger.trace("BrowserCacheManager.resetRequestCache called");
+    resetRequestCache(correlationId: string): void {
+        this.logger.trace(
+            "BrowserCacheManager.resetRequestCache called",
+            correlationId
+        );
 
         this.removeTemporaryItem(
             this.generateCacheKey(TemporaryCacheKeys.REQUEST_PARAMS)
@@ -1556,14 +1565,18 @@ export class BrowserCacheManager extends CacheManager {
         this.removeTemporaryItem(
             this.generateCacheKey(TemporaryCacheKeys.NATIVE_REQUEST)
         );
-        this.setInteractionInProgress(false);
+        this.setInteractionInProgress(false, undefined);
     }
 
     cacheAuthorizeRequest(
         authCodeRequest: CommonAuthorizationUrlRequest,
+        correlationId: string,
         codeVerifier?: string
     ): void {
-        this.logger.trace("BrowserCacheManager.cacheAuthorizeRequest called");
+        this.logger.trace(
+            "BrowserCacheManager.cacheAuthorizeRequest called",
+            correlationId
+        );
 
         const encodedValue = base64Encode(JSON.stringify(authCodeRequest));
         this.setTemporaryCache(
@@ -1584,12 +1597,19 @@ export class BrowserCacheManager extends CacheManager {
 
     /**
      * Gets the token exchange parameters from the cache. Throws an error if nothing is found.
+     * @param correlationId
      */
-    getCachedRequest(): [CommonAuthorizationUrlRequest, string] {
-        this.logger.trace("BrowserCacheManager.getCachedRequest called");
+    getCachedRequest(
+        correlationId: string
+    ): [CommonAuthorizationUrlRequest, string] {
+        this.logger.trace(
+            "BrowserCacheManager.getCachedRequest called",
+            correlationId
+        );
         // Get token request from cache and parse as TokenExchangeParameters.
         const encodedTokenRequest = this.getTemporaryCache(
             TemporaryCacheKeys.REQUEST_PARAMS,
+            correlationId,
             true
         );
         if (!encodedTokenRequest) {
@@ -1599,6 +1619,7 @@ export class BrowserCacheManager extends CacheManager {
         }
         const encodedVerifier = this.getTemporaryCache(
             TemporaryCacheKeys.VERIFIER,
+            correlationId,
             true
         );
 
@@ -1610,9 +1631,13 @@ export class BrowserCacheManager extends CacheManager {
                 verifier = base64Decode(encodedVerifier);
             }
         } catch (e) {
-            this.logger.errorPii(`Attempted to parse: ${encodedTokenRequest}`);
+            this.logger.errorPii(
+                `Attempted to parse: '${encodedTokenRequest}'`,
+                correlationId
+            );
             this.logger.error(
-                `Parsing cached token request threw with error: ${e}`
+                `Parsing cached token request threw with error: '${e}'`,
+                correlationId
             );
             throw createBrowserAuthError(
                 BrowserAuthErrorCodes.unableToParseTokenRequestCacheError
@@ -1624,16 +1649,22 @@ export class BrowserCacheManager extends CacheManager {
 
     /**
      * Gets cached native request for redirect flows
+     * @param correlationId
      */
     getCachedNativeRequest(): PlatformAuthRequest | null {
-        this.logger.trace("BrowserCacheManager.getCachedNativeRequest called");
+        this.logger.trace(
+            "BrowserCacheManager.getCachedNativeRequest called",
+            ""
+        );
         const cachedRequest = this.getTemporaryCache(
             TemporaryCacheKeys.NATIVE_REQUEST,
+            "",
             true
         );
         if (!cachedRequest) {
             this.logger.trace(
-                "BrowserCacheManager.getCachedNativeRequest: No cached native request found"
+                "BrowserCacheManager.getCachedNativeRequest: No cached native request found",
+                ""
             );
             return null;
         }
@@ -1643,7 +1674,8 @@ export class BrowserCacheManager extends CacheManager {
         ) as PlatformAuthRequest;
         if (!parsedRequest) {
             this.logger.error(
-                "BrowserCacheManager.getCachedNativeRequest: Unable to parse native request"
+                "BrowserCacheManager.getCachedNativeRequest: Unable to parse native request",
+                ""
             );
             return null;
         }
@@ -1666,16 +1698,17 @@ export class BrowserCacheManager extends CacheManager {
         type: INTERACTION_TYPE;
     } | null {
         const key = `${CacheKeys.PREFIX}.${TemporaryCacheKeys.INTERACTION_STATUS_KEY}`;
-        const value = this.getTemporaryCache(key, false);
+        const value = this.getTemporaryCache(key, "", false);
         try {
             return value ? JSON.parse(value) : null;
         } catch (e) {
             // Remove interaction and other temp keys if interaction status can't be parsed
             this.logger.error(
-                `Cannot parse interaction status. Removing temporary cache items and clearing url hash. Retrying interaction should fix the error`
+                `Cannot parse interaction status. Removing temporary cache items and clearing url hash. Retrying interaction should fix the error`,
+                ""
             );
             this.removeTemporaryItem(key);
-            this.resetRequestCache();
+            this.resetRequestCache("");
             clearHash(window);
             return null;
         }
@@ -1729,11 +1762,6 @@ export class BrowserCacheManager extends CacheManager {
             result.tenantId
         );
 
-        let claimsHash;
-        if (request.claims) {
-            claimsHash = await this.cryptoImpl.hashString(request.claims);
-        }
-
         /**
          * meta data for cache stores time in seconds from epoch
          * AuthenticationResult returns expiresOn and extExpiresOn in milliseconds (as a Date object which is in ms)
@@ -1758,11 +1786,9 @@ export class BrowserCacheManager extends CacheManager {
                 : 0,
             base64Decode,
             undefined, // refreshOn
-            result.tokenType as AuthenticationScheme,
+            result.tokenType as Constants.AuthenticationScheme,
             undefined, // userAssertionHash
-            request.sshKid,
-            request.claims,
-            claimsHash
+            request.sshKid
         );
 
         const cacheRecord = {
@@ -1835,7 +1861,7 @@ function getStorageImplementation(
                 break;
         }
     } catch (e) {
-        logger.error(e as string);
+        logger.error(e as string, "");
     }
 
     return new MemoryStorage();
@@ -1850,11 +1876,6 @@ export const DEFAULT_BROWSER_CACHE_MANAGER = (
     const cacheOptions: Required<CacheOptions> = {
         cacheLocation: BrowserCacheLocation.MemoryStorage,
         cacheRetentionDays: 5,
-        temporaryCacheLocation: BrowserCacheLocation.MemoryStorage,
-        storeAuthStateInCookie: false,
-        secureCookies: false,
-        cacheMigrationEnabled: false,
-        claimsBasedCachingEnabled: false,
     };
     return new BrowserCacheManager(
         clientId,