@azure/msal-browser 4.0.0-alpha.0 → 4.0.2

package/lib/types/request/SsoSilentRequest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SsoSilentRequest.d.ts","sourceRoot":"","sources":["../../../src/request/SsoSilentRequest.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,6BAA6B,EAC7B,UAAU,EACb,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAClC,IAAI,CACA,6BAA6B,EAC3B,cAAc,GACd,eAAe,GACf,qBAAqB,GACrB,qBAAqB,GACrB,cAAc,CACnB,CACJ,GAAG;IACA,mBAAmB,CAAC,EAAE,UAAU,CAAC;CACpC,CAAC"}
+{"version":3,"file":"SsoSilentRequest.d.ts","sourceRoot":"","sources":["../../../src/request/SsoSilentRequest.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,6BAA6B,EAC7B,UAAU,EACb,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAClC,IAAI,CACA,6BAA6B,EAC3B,cAAc,GACd,eAAe,GACf,qBAAqB,GACrB,qBAAqB,GACrB,gBAAgB,CACrB,CACJ,GAAG;IACA,mBAAmB,CAAC,EAAE,UAAU,CAAC;CACpC,CAAC"}

package/lib/types/utils/BrowserUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/BrowserUtils.ts"],"names":[],"mappings":"AAKA,OAAO,EAAa,MAAM,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAW5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAElE;;GAEG;AACH,wBAAgB,SAAS,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAWrD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAI7C;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAEpC;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAQnC;AAID;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAIpC;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAQjD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,qBAAqB,EAAE,OAAO,GAAG,IAAI,CAK1E;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAKhD;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAMjD;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI,CAMxE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI,CAYzD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAClC,WAAW,EAAE,OAAO,EACpB,MAAM,EAAE,oBAAoB,GAC7B,IAAI,CAYN;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAalD;AAED;;;GAGG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,OAAO,EAAE,MAAM,EAAE,CAAC;AAClB,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"BrowserUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/BrowserUtils.ts"],"names":[],"mappings":"AAKA,OAAO,EAAa,MAAM,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAW5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAElE;;GAEG;AACH,wBAAgB,SAAS,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAWrD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAI7C;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAEpC;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAQnC;AAID;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAItC;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAIpC;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAQjD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,qBAAqB,EAAE,OAAO,GAAG,IAAI,CAK1E;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAKhD;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAMjD;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI,CAMxE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI,CAYzD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAClC,WAAW,EAAE,OAAO,EACpB,MAAM,EAAE,oBAAoB,GAC7B,IAAI,CAYN;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAalD;AAED;;;GAGG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,OAAO,EAAE,MAAM,EAAE,CAAC;AAClB,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/package.json

@@ -10,7 +10,7 @@
     "type": "git",
     "url": "https://github.com/AzureAD/microsoft-authentication-library-for-js.git"
   },
-  "version": "4.0.0-alpha.0",
+  "version": "4.0.2",
   "description": "Microsoft Authentication Library for js",
   "keywords": [
     "implicit",
@@ -103,6 +103,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "@azure/msal-common": "15.0.0-alpha.0"
+    "@azure/msal-common": "15.0.2"
   }
 }

package/src/app/PublicClientApplication.ts

@@ -446,7 +446,12 @@ export async function createNestablePublicClientApplication(
 
     if (nestedAppAuth.isAvailable()) {
         const controller = new NestedAppAuthController(nestedAppAuth);
-        return new PublicClientApplication(configuration, controller);
+        const nestablePCA = new PublicClientApplication(
+            configuration,
+            controller
+        );
+        await nestablePCA.initialize();
+        return nestablePCA;
     }
 
     return createStandardPublicClientApplication(configuration);

package/src/broker/nativeBroker/NativeMessageHandler.ts

@@ -372,16 +372,16 @@ export class NativeMessageHandler {
      * @param nativeExtensionProvider
      * @param authenticationScheme
      */
-    static isNativeAvailable(
+    static isPlatformBrokerAvailable(
         config: BrowserConfiguration,
         logger: Logger,
         nativeExtensionProvider?: NativeMessageHandler,
         authenticationScheme?: AuthenticationScheme
     ): boolean {
-        logger.trace("isNativeAvailable called");
-        if (!config.system.allowNativeBroker) {
+        logger.trace("isPlatformBrokerAvailable called");
+        if (!config.system.allowPlatformBroker) {
             logger.trace(
-                "isNativeAvailable: allowNativeBroker is not enabled, returning false"
+                "isPlatformBrokerAvailable: allowPlatformBroker is not enabled, returning false"
             );
             // Developer disabled WAM
             return false;
@@ -389,7 +389,7 @@ export class NativeMessageHandler {
 
         if (!nativeExtensionProvider) {
             logger.trace(
-                "isNativeAvailable: WAM extension provider is not initialized, returning false"
+                "isPlatformBrokerAvailable: Platform extension provider is not initialized, returning false"
             );
             // Extension is not available
             return false;
@@ -400,12 +400,12 @@ export class NativeMessageHandler {
                 case AuthenticationScheme.BEARER:
                 case AuthenticationScheme.POP:
                     logger.trace(
-                        "isNativeAvailable: authenticationScheme is supported, returning true"
+                        "isPlatformBrokerAvailable: authenticationScheme is supported, returning true"
                     );
                     return true;
                 default:
                     logger.trace(
-                        "isNativeAvailable: authenticationScheme is not supported, returning false"
+                        "isPlatformBrokerAvailable: authenticationScheme is not supported, returning false"
                     );
                     return false;
             }

package/src/broker/nativeBroker/NativeResponse.ts

@@ -13,7 +13,7 @@ export type NativeAccountInfo = {
 };
 
 /**
- * Token response returned by Native Platform e.g. WAM
+ * Token response returned by Native Platform
  */
 export type NativeResponse = {
     access_token: string;

package/src/cache/BrowserCacheManager.ts

@@ -37,6 +37,7 @@ import {
     CacheHelpers,
     StoreInCache,
     CacheError,
+    invokeAsync,
 } from "@azure/msal-common/browser";
 import { CacheOptions } from "../config/Configuration.js";
 import {
@@ -85,57 +86,39 @@ export class BrowserCacheManager extends CacheManager {
     // Logger instance
     protected logger: Logger;
     // Telemetry perf client
-    protected performanceClient?: IPerformanceClient;
+    protected performanceClient: IPerformanceClient;
 
     constructor(
         clientId: string,
         cacheConfig: Required<CacheOptions>,
         cryptoImpl: ICrypto,
         logger: Logger,
-        staticAuthorityOptions?: StaticAuthorityOptions,
-        performanceClient?: IPerformanceClient
+        performanceClient: IPerformanceClient,
+        staticAuthorityOptions?: StaticAuthorityOptions
     ) {
         super(clientId, cryptoImpl, logger, staticAuthorityOptions);
         this.cacheConfig = cacheConfig;
         this.logger = logger;
         this.internalStorage = new MemoryStorage();
-        this.browserStorage = this.setupBrowserStorage(
-            this.cacheConfig.cacheLocation
+        this.browserStorage = getStorageImplementation(
+            clientId,
+            cacheConfig.cacheLocation,
+            logger,
+            performanceClient
         );
-        this.temporaryCacheStorage = this.setupBrowserStorage(
-            this.cacheConfig.temporaryCacheLocation
+        this.temporaryCacheStorage = getStorageImplementation(
+            clientId,
+            cacheConfig.temporaryCacheLocation,
+            logger,
+            performanceClient
         );
         this.cookieStorage = new CookieStorage();
 
         this.performanceClient = performanceClient;
     }
 
-    async initialize(): Promise<void> {
-        await this.browserStorage.initialize();
-    }
-
-    /**
-     * Returns a window storage class implementing the IWindowStorage interface that corresponds to the configured cacheLocation.
-     * @param cacheLocation
-     */
-    protected setupBrowserStorage(
-        cacheLocation: BrowserCacheLocation | string
-    ): IWindowStorage<string> {
-        try {
-            switch (cacheLocation) {
-                case BrowserCacheLocation.LocalStorage:
-                    return new LocalStorage(this.clientId);
-                case BrowserCacheLocation.SessionStorage:
-                    return new SessionStorage();
-                case BrowserCacheLocation.MemoryStorage:
-                default:
-                    break;
-            }
-        } catch (e) {
-            this.logger.error(e as string);
-        }
-        this.cacheConfig.cacheLocation = BrowserCacheLocation.MemoryStorage;
-        return new MemoryStorage();
+    async initialize(correlationId: string): Promise<void> {
+        await this.browserStorage.initialize(correlationId);
     }
 
     /**
@@ -189,10 +172,18 @@ export class BrowserCacheManager extends CacheManager {
      * set account entity in the platform cache
      * @param account
      */
-    async setAccount(account: AccountEntity): Promise<void> {
+    async setAccount(
+        account: AccountEntity,
+        correlationId: string
+    ): Promise<void> {
         this.logger.trace("BrowserCacheManager.setAccount called");
         const key = account.generateAccountKey();
-        await this.browserStorage.setUserData(key, JSON.stringify(account));
+        await invokeAsync(
+            this.browserStorage.setUserData.bind(this.browserStorage),
+            PerformanceEvents.SetUserData,
+            this.logger,
+            this.performanceClient
+        )(key, JSON.stringify(account), correlationId);
         this.addAccountKeyToMap(key);
     }
 
@@ -457,14 +448,19 @@ export class BrowserCacheManager extends CacheManager {
      * set IdToken credential to the platform cache
      * @param idToken
      */
-    async setIdTokenCredential(idToken: IdTokenEntity): Promise<void> {
+    async setIdTokenCredential(
+        idToken: IdTokenEntity,
+        correlationId: string
+    ): Promise<void> {
         this.logger.trace("BrowserCacheManager.setIdTokenCredential called");
         const idTokenKey = CacheHelpers.generateCredentialKey(idToken);
 
-        await this.browserStorage.setUserData(
-            idTokenKey,
-            JSON.stringify(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);
     }
@@ -505,16 +501,19 @@ export class BrowserCacheManager extends CacheManager {
      * @param accessToken
      */
     async setAccessTokenCredential(
-        accessToken: AccessTokenEntity
+        accessToken: AccessTokenEntity,
+        correlationId: string
     ): Promise<void> {
         this.logger.trace(
             "BrowserCacheManager.setAccessTokenCredential called"
         );
         const accessTokenKey = CacheHelpers.generateCredentialKey(accessToken);
-        await this.browserStorage.setUserData(
-            accessTokenKey,
-            JSON.stringify(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);
     }
@@ -557,17 +556,20 @@ export class BrowserCacheManager extends CacheManager {
      * @param refreshToken
      */
     async setRefreshTokenCredential(
-        refreshToken: RefreshTokenEntity
+        refreshToken: RefreshTokenEntity,
+        correlationId: string
     ): Promise<void> {
         this.logger.trace(
             "BrowserCacheManager.setRefreshTokenCredential called"
         );
         const refreshTokenKey =
             CacheHelpers.generateCredentialKey(refreshToken);
-        await this.browserStorage.setUserData(
-            refreshTokenKey,
-            JSON.stringify(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);
     }
@@ -1404,7 +1406,7 @@ export class BrowserCacheManager extends CacheManager {
             idToken: idTokenEntity,
             accessToken: accessTokenEntity,
         };
-        return this.saveCacheRecord(cacheRecord);
+        return this.saveCacheRecord(cacheRecord, result.correlationId);
     }
 
     /**
@@ -1415,14 +1417,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 (
@@ -1449,9 +1451,37 @@ export class BrowserCacheManager extends CacheManager {
     }
 }
 
+/**
+ * Returns a window storage class implementing the IWindowStorage interface that corresponds to the configured cacheLocation.
+ * @param cacheLocation
+ */
+function getStorageImplementation(
+    clientId: string,
+    cacheLocation: BrowserCacheLocation | string,
+    logger: Logger,
+    performanceClient: IPerformanceClient
+): IWindowStorage<string> {
+    try {
+        switch (cacheLocation) {
+            case BrowserCacheLocation.LocalStorage:
+                return new LocalStorage(clientId, logger, performanceClient);
+            case BrowserCacheLocation.SessionStorage:
+                return new SessionStorage();
+            case BrowserCacheLocation.MemoryStorage:
+            default:
+                break;
+        }
+    } catch (e) {
+        logger.error(e as string);
+    }
+
+    return new MemoryStorage();
+}
+
 export const DEFAULT_BROWSER_CACHE_MANAGER = (
     clientId: string,
-    logger: Logger
+    logger: Logger,
+    performanceClient: IPerformanceClient
 ): BrowserCacheManager => {
     const cacheOptions: Required<CacheOptions> = {
         cacheLocation: BrowserCacheLocation.MemoryStorage,
@@ -1465,6 +1495,7 @@ export const DEFAULT_BROWSER_CACHE_MANAGER = (
         clientId,
         cacheOptions,
         DEFAULT_CRYPTO_IMPLEMENTATION,
-        logger
+        logger,
+        performanceClient
     );
 };

package/src/cache/IWindowStorage.ts

@@ -7,7 +7,7 @@ export interface IWindowStorage<T> {
     /**
      * Async initializer
      */
-    initialize(): Promise<void>;
+    initialize(correlationId: string): Promise<void>;
     /**
      * Get the item from the window storage object matching the given key.
      * @param key
@@ -29,7 +29,7 @@ export interface IWindowStorage<T> {
     /**
      * Setter for sensitive data that may contain PII.
      */
-    setUserData(key: string, value: T): Promise<void>;
+    setUserData(key: string, value: T, correlationId: string): Promise<void>;
 
     /**
      * Removes the item in the window storage object matching the given key.

package/src/cache/LocalStorage.ts

@@ -3,7 +3,15 @@
  * Licensed under the MIT License.
  */
 
-import { Constants, TokenKeys } from "@azure/msal-common/browser";
+import {
+    Constants,
+    TokenKeys,
+    IPerformanceClient,
+    invokeAsync,
+    PerformanceEvents,
+    Logger,
+    invoke,
+} from "@azure/msal-common/browser";
 import {
     createNewGuid,
     decrypt,
@@ -25,6 +33,7 @@ import { CookieStorage } from "./CookieStorage.js";
 import { IWindowStorage } from "./IWindowStorage.js";
 import { MemoryStorage } from "./MemoryStorage.js";
 import { getAccountKeys, getTokenKeys } from "./CacheHelpers.js";
+import { StaticCacheKeys } from "../utils/BrowserConstants.js";
 
 const ENCRYPTION_KEY = "msal.cache.encryption";
 
@@ -43,9 +52,15 @@ export class LocalStorage implements IWindowStorage<string> {
     private clientId: string;
     private initialized: boolean;
     private memoryStorage: MemoryStorage<string>;
+    private performanceClient: IPerformanceClient;
+    private logger: Logger;
     private encryptionCookie?: EncryptionCookie;
 
-    constructor(clientId: string) {
+    constructor(
+        clientId: string,
+        logger: Logger,
+        performanceClient: IPerformanceClient
+    ) {
         if (!window.localStorage) {
             throw createBrowserConfigurationAuthError(
                 BrowserConfigurationAuthErrorCodes.storageNotSupported
@@ -54,9 +69,11 @@ export class LocalStorage implements IWindowStorage<string> {
         this.memoryStorage = new MemoryStorage<string>();
         this.initialized = false;
         this.clientId = clientId;
+        this.logger = logger;
+        this.performanceClient = performanceClient;
     }
 
-    async initialize(): Promise<void> {
+    async initialize(correlationId: string): Promise<void> {
         this.initialized = true;
 
         const cookies = new CookieStorage();
@@ -65,26 +82,61 @@ export class LocalStorage implements IWindowStorage<string> {
         if (cookieString) {
             try {
                 parsedCookie = JSON.parse(cookieString);
-            } catch (e) {
-                // TODO: Log telemetry but don't throw
-            }
+            } catch (e) {}
         }
         if (parsedCookie.key && parsedCookie.id) {
             // Encryption key already exists, import
+            const baseKey = invoke(
+                base64DecToArr,
+                PerformanceEvents.Base64Decode,
+                this.logger,
+                this.performanceClient,
+                correlationId
+            )(parsedCookie.key);
             this.encryptionCookie = {
                 id: parsedCookie.id,
-                key: await generateHKDF(base64DecToArr(parsedCookie.key)),
+                key: await invokeAsync(
+                    generateHKDF,
+                    PerformanceEvents.GenerateHKDF,
+                    this.logger,
+                    this.performanceClient,
+                    correlationId
+                )(baseKey),
             };
-            await this.importExistingCache();
+            await invokeAsync(
+                this.importExistingCache.bind(this),
+                PerformanceEvents.ImportExistingCache,
+                this.logger,
+                this.performanceClient,
+                correlationId
+            )(correlationId);
         } else {
             // Encryption key doesn't exist or is invalid, generate a new one and clear existing cache
             this.clear();
             const id = createNewGuid();
-            const baseKey = await generateBaseKey();
-            const keyStr = urlEncodeArr(new Uint8Array(baseKey));
+            const baseKey = await invokeAsync(
+                generateBaseKey,
+                PerformanceEvents.GenerateBaseKey,
+                this.logger,
+                this.performanceClient,
+                correlationId
+            )();
+            const keyStr = invoke(
+                urlEncodeArr,
+                PerformanceEvents.UrlEncodeArr,
+                this.logger,
+                this.performanceClient,
+                correlationId
+            )(new Uint8Array(baseKey));
             this.encryptionCookie = {
                 id: id,
-                key: await generateHKDF(baseKey),
+                key: await invokeAsync(
+                    generateHKDF,
+                    PerformanceEvents.GenerateHKDF,
+                    this.logger,
+                    this.performanceClient,
+                    correlationId
+                )(baseKey),
             };
 
             const cookieData = {
@@ -112,18 +164,24 @@ export class LocalStorage implements IWindowStorage<string> {
         window.localStorage.setItem(key, value);
     }
 
-    async setUserData(key: string, value: string): Promise<void> {
+    async setUserData(
+        key: string,
+        value: string,
+        correlationId: string
+    ): Promise<void> {
         if (!this.initialized || !this.encryptionCookie) {
             throw createBrowserAuthError(
                 BrowserAuthErrorCodes.uninitializedPublicClientApplication
             );
         }
 
-        const { data, nonce } = await encrypt(
-            this.encryptionCookie.key,
-            value,
-            this.getContext(key)
-        );
+        const { data, nonce } = await invokeAsync(
+            encrypt,
+            PerformanceEvents.Encrypt,
+            this.logger,
+            this.performanceClient,
+            correlationId
+        )(this.encryptionCookie.key, value, this.getContext(key));
         const encryptedData: EncryptedData = {
             id: this.encryptionCookie.id,
             nonce: nonce,
@@ -176,20 +234,34 @@ export class LocalStorage implements IWindowStorage<string> {
      * Helper to decrypt all known MSAL keys in localStorage and save them to inMemory storage
      * @returns
      */
-    private async importExistingCache(): Promise<void> {
+    private async importExistingCache(correlationId: string): Promise<void> {
         if (!this.encryptionCookie) {
             return;
         }
 
-        const accountKeys = getAccountKeys(this);
-        await this.importArray(accountKeys);
+        let accountKeys = getAccountKeys(this);
+        accountKeys = await this.importArray(accountKeys, correlationId);
+        // Write valid account keys back to map
+        this.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
 
         const tokenKeys: TokenKeys = getTokenKeys(this.clientId, this);
-        await Promise.all([
-            this.importArray(tokenKeys.idToken),
-            this.importArray(tokenKeys.accessToken),
-            this.importArray(tokenKeys.refreshToken),
-        ]);
+        tokenKeys.idToken = await this.importArray(
+            tokenKeys.idToken,
+            correlationId
+        );
+        tokenKeys.accessToken = await this.importArray(
+            tokenKeys.accessToken,
+            correlationId
+        );
+        tokenKeys.refreshToken = await this.importArray(
+            tokenKeys.refreshToken,
+            correlationId
+        );
+        // Write valid token keys back to map
+        this.setItem(
+            `${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`,
+            JSON.stringify(tokenKeys)
+        );
     }
 
     /**
@@ -198,7 +270,8 @@ export class LocalStorage implements IWindowStorage<string> {
      * @returns
      */
     private async getItemFromEncryptedCache(
-        key: string
+        key: string,
+        correlationId: string
     ): Promise<string | null> {
         if (!this.encryptionCookie) {
             return null;
@@ -212,21 +285,36 @@ export class LocalStorage implements IWindowStorage<string> {
         let encObj: EncryptedData;
         try {
             encObj = JSON.parse(rawCache);
-            if (!encObj.id || !encObj.nonce || !encObj.data) {
-                throw "Not encrypted!"; // TODO: Typed error
-            }
-
-            if (encObj.id !== this.encryptionCookie.id) {
-                throw "Old item!"; // TODO: Typed error
-            }
         } catch (e) {
             // Not a valid encrypted object, remove
-            this.removeItem(key);
-            // TODO: Log to telemetry
             return null;
         }
 
-        return decrypt(
+        if (!encObj.id || !encObj.nonce || !encObj.data) {
+            // Data is not encrypted, likely from old version of MSAL. It must be removed because we don't know how old it is.
+            this.performanceClient.incrementFields(
+                { unencryptedCacheCount: 1 },
+                correlationId
+            );
+            return null;
+        }
+
+        if (encObj.id !== this.encryptionCookie.id) {
+            // Data was encrypted with a different key. It must be removed because it is from a previous session.
+            this.performanceClient.incrementFields(
+                { encryptedCacheExpiredCount: 1 },
+                correlationId
+            );
+            return null;
+        }
+
+        return invokeAsync(
+            decrypt,
+            PerformanceEvents.Decrypt,
+            this.logger,
+            this.performanceClient,
+            correlationId
+        )(
             this.encryptionCookie.key,
             encObj.nonce,
             this.getContext(key),
@@ -237,21 +325,32 @@ export class LocalStorage implements IWindowStorage<string> {
     /**
      * Helper to decrypt and save an array of cache keys
      * @param arr
+     * @returns Array of keys successfully imported
      */
-    private async importArray(arr: Array<string>): Promise<void> {
+    private async importArray(
+        arr: Array<string>,
+        correlationId: string
+    ): Promise<Array<string>> {
+        const importedArr: Array<string> = [];
         const promiseArr: Array<Promise<void>> = [];
         arr.forEach((key) => {
-            const promise = this.getItemFromEncryptedCache(key).then(
-                (value) => {
-                    if (value) {
-                        this.memoryStorage.setItem(key, value);
-                    }
+            const promise = this.getItemFromEncryptedCache(
+                key,
+                correlationId
+            ).then((value) => {
+                if (value) {
+                    this.memoryStorage.setItem(key, value);
+                    importedArr.push(key);
+                } else {
+                    // If value is empty, unencrypted or expired remove
+                    this.removeItem(key);
                 }
-            );
+            });
             promiseArr.push(promise);
         });
 
         await Promise.all(promiseArr);
+        return importedArr;
     }
 
     /**