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

package/dist/controllers/StandardController.mjs

@@ -1,7 +1,9 @@
-/*! @azure/msal-browser v4.24.0 2025-09-24 */
+/*! @azure/msal-browser v5.0.0-alpha.0 2025-10-02 */
 'use strict';
 import { CryptoOps } from '../crypto/CryptoOps.mjs';
-import { DEFAULT_CRYPTO_IMPLEMENTATION, buildStaticAuthorityOptions, PerformanceEvents, invokeAsync, invoke, InteractionRequiredAuthError, createClientAuthError, ClientAuthErrorCodes, AccountEntity, PromptValue, Constants, AuthError, getRequestThumbprint, InteractionRequiredAuthErrorCodes } from '@azure/msal-common/browser';
+import { DEFAULT_CRYPTO_IMPLEMENTATION, buildStaticAuthorityOptions, invokeAsync, InteractionRequiredAuthError, createClientAuthError, ClientAuthErrorCodes, AccountEntityUtils, Constants, AuthError, getRequestThumbprint, InteractionRequiredAuthErrorCodes } from '@azure/msal-common/browser';
+import { InitializeCache, HandleNativeRedirectPromiseMeasurement, HandleRedirectPromiseMeasurement, AcquireTokenByCodeAsync, SilentCacheClientAcquireToken, SilentRefreshClientAcquireToken, SilentIframeClientAcquireToken, AcquireTokenSilentAsync, InitializeSilentRequest, AcquireTokenBySilentIframe, AwaitConcurrentIframe, AcquireTokenFromCache, AcquireTokenByRefreshToken, GeneratePkceCodes } from '../telemetry/BrowserPerformanceEvents.mjs';
+import { InitializeClientApplication, AcquireTokenRedirect, AcquireTokenPreRedirect, AcquireTokenPopup, SsoSilent, AcquireTokenByCode, AcquireTokenSilent } from '../telemetry/BrowserRootPerformanceEvents.mjs';
 import { BrowserCacheManager, DEFAULT_BROWSER_CACHE_MANAGER } from '../cache/BrowserCacheManager.mjs';
 import { getAllAccounts, getAccount, getAccountByUsername, getAccountByHomeId, getAccountByLocalId, setActiveAccount, getActiveAccount } from '../cache/AccountManager.mjs';
 import { BrowserCacheLocation, INTERACTION_TYPE, InteractionType, ApiId, CacheLookupPolicy, DEFAULT_REQUEST, iFrameRenewalPolicies, BrowserConstants } from '../utils/BrowserConstants.mjs';
@@ -12,7 +14,6 @@ import { PopupClient } from '../interaction_client/PopupClient.mjs';
 import { RedirectClient } from '../interaction_client/RedirectClient.mjs';
 import { SilentIframeClient } from '../interaction_client/SilentIframeClient.mjs';
 import { SilentRefreshClient } from '../interaction_client/SilentRefreshClient.mjs';
-import { TokenCache } from '../cache/TokenCache.mjs';
 import { PlatformAuthInteractionClient } from '../interaction_client/PlatformAuthInteractionClient.mjs';
 import { NativeAuthError, isFatalNativeAuthError } from '../error/NativeAuthError.mjs';
 import { SilentCacheClient } from '../interaction_client/SilentCacheClient.mjs';
@@ -29,12 +30,25 @@ import { spaCodeAndNativeAccountIdPresent, unableToAcquireTokenFromNativePlatfor
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-function preflightCheck(initialized, performanceEvent, account) {
+function getAccountType(account) {
+    const idTokenClaims = account?.idTokenClaims;
+    if (idTokenClaims?.tfp || idTokenClaims?.acr) {
+        return "B2C";
+    }
+    if (!idTokenClaims?.tid) {
+        return undefined;
+    }
+    else if (idTokenClaims?.tid === "9188040d-6c67-4c5b-b112-36a304b66dad") {
+        return "MSA";
+    }
+    return "AAD";
+}
+function preflightCheck(initialized, performanceEvent) {
     try {
         preflightCheck$1(initialized);
     }
     catch (e) {
-        performanceEvent.end({ success: false }, e, account);
+        performanceEvent.end({ success: false }, e);
         throw e;
     }
 }
@@ -92,15 +106,8 @@ class StandardController {
         const nativeCacheOptions = {
             cacheLocation: BrowserCacheLocation.MemoryStorage,
             cacheRetentionDays: 5,
-            temporaryCacheLocation: BrowserCacheLocation.MemoryStorage,
-            storeAuthStateInCookie: false,
-            secureCookies: false,
-            cacheMigrationEnabled: false,
-            claimsBasedCachingEnabled: false,
         };
         this.nativeInternalStorage = new BrowserCacheManager(this.config.auth.clientId, nativeCacheOptions, this.browserCrypto, this.logger, this.performanceClient, this.eventHandler);
-        // Initialize the token cache
-        this.tokenCache = new TokenCache(this.config, this.browserStorage, this.logger, this.browserCrypto);
         this.activeSilentTokenRequests = new Map();
         // Register listener functions
         this.trackPageVisibility = this.trackPageVisibility.bind(this);
@@ -117,7 +124,7 @@ class StandardController {
         if (!correlationId) {
             return;
         }
-        this.logger.info("Perf: Visibility change detected");
+        this.logger.info("Perf: Visibility change detected", correlationId);
         this.performanceClient.incrementFields({ visibilityChangeCount: 1 }, correlationId);
     }
     /**
@@ -125,43 +132,44 @@ class StandardController {
      * @param request {?InitializeApplicationRequest} correlation id
      */
     async initialize(request, isBroker) {
-        this.logger.trace("initialize called");
+        const correlationId = this.getRequestCorrelationId(request);
+        this.logger.trace("initialize called", correlationId);
         if (this.initialized) {
-            this.logger.info("initialize has already been called, exiting early.");
+            this.logger.info("initialize has already been called, exiting early.", correlationId);
             return;
         }
         if (!this.isBrowserEnvironment) {
-            this.logger.info("in non-browser environment, exiting early.");
+            this.logger.info("in non-browser environment, exiting early.", correlationId);
             this.initialized = true;
             this.eventHandler.emitEvent(EventType.INITIALIZE_END);
             return;
         }
         const initCorrelationId = request?.correlationId || this.getRequestCorrelationId();
         const allowPlatformBroker = this.config.system.allowPlatformBroker;
-        const initMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.InitializeClientApplication, initCorrelationId);
+        const initMeasurement = this.performanceClient.startMeasurement(InitializeClientApplication, initCorrelationId);
         this.eventHandler.emitEvent(EventType.INITIALIZE_START);
         // Broker applications are initialized twice, so we avoid double-counting it
         if (!isBroker) {
             try {
-                this.logMultipleInstances(initMeasurement);
+                this.logMultipleInstances(initMeasurement, initCorrelationId);
             }
             catch { }
         }
-        await invokeAsync(this.browserStorage.initialize.bind(this.browserStorage), PerformanceEvents.InitializeCache, this.logger, this.performanceClient, initCorrelationId)(initCorrelationId);
+        await invokeAsync(this.browserStorage.initialize.bind(this.browserStorage), InitializeCache, this.logger, this.performanceClient, initCorrelationId)(initCorrelationId);
         if (allowPlatformBroker) {
             try {
                 // check if platform authentication is available via DOM or browser extension and create relevant handlers
                 this.platformAuthProvider = await getPlatformAuthProvider(this.logger, this.performanceClient, initCorrelationId, this.config.system.nativeBrokerHandshakeTimeout);
             }
             catch (e) {
-                this.logger.verbose(e);
+                this.logger.verbose(e, initCorrelationId);
             }
         }
-        if (!this.config.cache.claimsBasedCachingEnabled) {
-            this.logger.verbose("Claims-based caching is disabled. Clearing the previous cache with claims");
-            invoke(this.browserStorage.clearTokensAndKeysWithClaims.bind(this.browserStorage), PerformanceEvents.ClearTokensAndKeysWithClaims, this.logger, this.performanceClient, initCorrelationId)(initCorrelationId);
+        if (this.config.cache.cacheLocation ===
+            BrowserCacheLocation.LocalStorage) {
+            this.eventHandler.subscribeCrossTab();
         }
-        this.config.system.asyncPopups &&
+        !this.config.system.navigatePopups &&
             (await this.preGeneratePkceCodes(initCorrelationId));
         this.initialized = true;
         this.eventHandler.emitEvent(EventType.INITIALIZE_END);
@@ -176,10 +184,11 @@ class StandardController {
      * has loaded during redirect flows. This should be invoked on all page loads involved in redirect
      * auth flows.
      * @param hash Hash to process. Defaults to the current value of window.location.hash. Only needs to be provided explicitly if the response to be handled is not contained in the current value.
+     * @param options Object containing optional configuration for redirect promise handling.
      * @returns Token response or null. If the return value is null, then no auth redirect was detected.
      */
-    async handleRedirectPromise(hash) {
-        this.logger.verbose("handleRedirectPromise called");
+    async handleRedirectPromise(options) {
+        this.logger.verbose("handleRedirectPromise called", "");
         // Block token acquisition before initialize has been called
         blockAPICallsBeforeInitialize(this.initialized);
         if (this.isBrowserEnvironment) {
@@ -188,19 +197,19 @@ class StandardController {
              * otherwise return the promise from the first invocation. Prevents race conditions when handleRedirectPromise is called
              * several times concurrently.
              */
-            const redirectResponseKey = hash || "";
+            const redirectResponseKey = options?.hash || "";
             let response = this.redirectResponse.get(redirectResponseKey);
             if (typeof response === "undefined") {
-                response = this.handleRedirectPromiseInternal(hash);
+                response = this.handleRedirectPromiseInternal(options);
                 this.redirectResponse.set(redirectResponseKey, response);
-                this.logger.verbose("handleRedirectPromise has been called for the first time, storing the promise");
+                this.logger.verbose("handleRedirectPromise has been called for the first time, storing the promise", "");
             }
             else {
-                this.logger.verbose("handleRedirectPromise has been called previously, returning the result from the first call");
+                this.logger.verbose("handleRedirectPromise has been called previously, returning the result from the first call", "");
             }
             return response;
         }
-        this.logger.verbose("handleRedirectPromise returns null, not browser environment");
+        this.logger.verbose("handleRedirectPromise returns null, not browser environment", "");
         return null;
     }
     /**
@@ -208,64 +217,63 @@ class StandardController {
      * @param hash
      * @returns
      */
-    async handleRedirectPromiseInternal(hash) {
+    async handleRedirectPromiseInternal(options) {
         if (!this.browserStorage.isInteractionInProgress(true)) {
-            this.logger.info("handleRedirectPromise called but there is no interaction in progress, returning null.");
+            this.logger.info("handleRedirectPromise called but there is no interaction in progress, returning null.", "");
             return null;
         }
         const interactionType = this.browserStorage.getInteractionInProgress()?.type;
         if (interactionType === INTERACTION_TYPE.SIGNOUT) {
-            this.logger.verbose("handleRedirectPromise removing interaction_in_progress flag and returning null after sign-out");
+            this.logger.verbose("handleRedirectPromise removing interaction_in_progress flag and returning null after sign-out", "");
             this.browserStorage.setInteractionInProgress(false);
             return Promise.resolve(null);
         }
         const loggedInAccounts = this.getAllAccounts();
         const platformBrokerRequest = this.browserStorage.getCachedNativeRequest();
-        const useNative = platformBrokerRequest && this.platformAuthProvider && !hash;
+        const useNative = platformBrokerRequest &&
+            this.platformAuthProvider &&
+            !options?.hash;
         let rootMeasurement;
         this.eventHandler.emitEvent(EventType.HANDLE_REDIRECT_START, InteractionType.Redirect);
         let redirectResponse;
         try {
             if (useNative && this.platformAuthProvider) {
-                rootMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenRedirect, platformBrokerRequest?.correlationId || "");
-                this.logger.trace("handleRedirectPromise - acquiring token from native platform");
-                rootMeasurement.add({
-                    isPlatformBrokerRequest: true,
-                });
+                const correlationId = platformBrokerRequest?.correlationId || "";
+                rootMeasurement = this.performanceClient.startMeasurement(AcquireTokenRedirect, correlationId);
+                this.logger.trace("handleRedirectPromise - acquiring token from native platform", correlationId);
                 const nativeClient = new PlatformAuthInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.handleRedirectPromise, this.performanceClient, this.platformAuthProvider, platformBrokerRequest.accountId, this.nativeInternalStorage, platformBrokerRequest.correlationId);
-                redirectResponse = invokeAsync(nativeClient.handleRedirectPromise.bind(nativeClient), PerformanceEvents.HandleNativeRedirectPromiseMeasurement, this.logger, this.performanceClient, rootMeasurement.event.correlationId)(this.performanceClient, rootMeasurement.event.correlationId);
+                redirectResponse = invokeAsync(nativeClient.handleRedirectPromise.bind(nativeClient), HandleNativeRedirectPromiseMeasurement, this.logger, this.performanceClient, rootMeasurement.event.correlationId)(this.performanceClient, rootMeasurement.event.correlationId);
             }
             else {
-                const [standardRequest, codeVerifier] = this.browserStorage.getCachedRequest();
+                const [standardRequest, codeVerifier] = this.browserStorage.getCachedRequest("");
                 const correlationId = standardRequest.correlationId;
                 // Reset rootMeasurement now that we have correlationId
-                rootMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenRedirect, correlationId);
-                this.logger.trace("handleRedirectPromise - acquiring token from web flow");
+                rootMeasurement = this.performanceClient.startMeasurement(AcquireTokenRedirect, correlationId);
+                this.logger.trace("handleRedirectPromise - acquiring token from web flow", correlationId);
                 const redirectClient = this.createRedirectClient(correlationId);
-                redirectResponse = invokeAsync(redirectClient.handleRedirectPromise.bind(redirectClient), PerformanceEvents.HandleRedirectPromiseMeasurement, this.logger, this.performanceClient, rootMeasurement.event.correlationId)(hash, standardRequest, codeVerifier, rootMeasurement);
+                redirectResponse = invokeAsync(redirectClient.handleRedirectPromise.bind(redirectClient), HandleRedirectPromiseMeasurement, this.logger, this.performanceClient, rootMeasurement.event.correlationId)(standardRequest, codeVerifier, rootMeasurement, options);
             }
         }
         catch (e) {
-            this.browserStorage.resetRequestCache();
+            this.browserStorage.resetRequestCache("");
             throw e;
         }
         return redirectResponse
             .then((result) => {
             if (result) {
-                this.browserStorage.resetRequestCache();
+                this.browserStorage.resetRequestCache(result.correlationId);
+                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Redirect, result);
+                this.logger.verbose("handleRedirectResponse returned result, acquire token success", result.correlationId);
                 // Emit login event if number of accounts change
                 const isLoggingIn = loggedInAccounts.length < this.getAllAccounts().length;
                 if (isLoggingIn) {
-                    this.eventHandler.emitEvent(EventType.LOGIN_SUCCESS, InteractionType.Redirect, result);
-                    this.logger.verbose("handleRedirectResponse returned result, login success");
-                }
-                else {
-                    this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Redirect, result);
-                    this.logger.verbose("handleRedirectResponse returned result, acquire token success");
+                    this.eventHandler.emitEvent(EventType.LOGIN_SUCCESS, InteractionType.Redirect, result.account);
+                    this.logger.verbose("handleRedirectResponse returned result, login success", result.correlationId);
                 }
                 rootMeasurement.end({
                     success: true,
-                }, undefined, result.account);
+                    accountType: getAccountType(result.account),
+                });
             }
             else {
                 /*
@@ -273,7 +281,7 @@ class StandardController {
                  * is empty and the error code is missing.
                  */
                 if (rootMeasurement.event.errorCode) {
-                    rootMeasurement.end({ success: false }, undefined);
+                    rootMeasurement.end({ success: false });
                 }
                 else {
                     rootMeasurement.discard();
@@ -283,15 +291,9 @@ class StandardController {
             return result;
         })
             .catch((e) => {
-            this.browserStorage.resetRequestCache();
+            this.browserStorage.resetRequestCache(rootMeasurement.event.correlationId);
             const eventError = e;
-            // Emit login event if there is an account
-            if (loggedInAccounts.length > 0) {
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Redirect, null, eventError);
-            }
-            else {
-                this.eventHandler.emitEvent(EventType.LOGIN_FAILURE, InteractionType.Redirect, null, eventError);
-            }
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Redirect, null, eventError);
             this.eventHandler.emitEvent(EventType.HANDLE_REDIRECT_END, InteractionType.Redirect);
             rootMeasurement.end({
                 success: false,
@@ -312,50 +314,27 @@ class StandardController {
         // Preflight request
         const correlationId = this.getRequestCorrelationId(request);
         this.logger.verbose("acquireTokenRedirect called", correlationId);
-        const atrMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenPreRedirect, correlationId);
+        const atrMeasurement = this.performanceClient.startMeasurement(AcquireTokenPreRedirect, correlationId);
         atrMeasurement.add({
+            accountType: getAccountType(request.account),
             scenarioId: request.scenarioId,
         });
-        // Override on request only if set, as onRedirectNavigate field is deprecated
-        const onRedirectNavigateCb = request.onRedirectNavigate;
-        if (onRedirectNavigateCb) {
-            request.onRedirectNavigate = (url) => {
-                const navigate = typeof onRedirectNavigateCb === "function"
-                    ? onRedirectNavigateCb(url)
-                    : undefined;
-                atrMeasurement.add({
-                    navigateCallbackResult: navigate !== false,
-                });
-                atrMeasurement.event =
-                    atrMeasurement.end({ success: true }, undefined, request.account) || atrMeasurement.event;
-                return navigate;
-            };
-        }
-        else {
-            const configOnRedirectNavigateCb = this.config.auth.onRedirectNavigate;
-            this.config.auth.onRedirectNavigate = (url) => {
-                const navigate = typeof configOnRedirectNavigateCb === "function"
-                    ? configOnRedirectNavigateCb(url)
-                    : undefined;
-                atrMeasurement.add({
-                    navigateCallbackResult: navigate !== false,
-                });
-                atrMeasurement.event =
-                    atrMeasurement.end({ success: true }, undefined, request.account) || atrMeasurement.event;
-                return navigate;
-            };
-        }
-        // If logged in, emit acquire token events
-        const isLoggedIn = this.getAllAccounts().length > 0;
+        const configOnRedirectNavigateCb = this.config.auth.onRedirectNavigate;
+        this.config.auth.onRedirectNavigate = (url) => {
+            const navigate = typeof configOnRedirectNavigateCb === "function"
+                ? configOnRedirectNavigateCb(url)
+                : undefined;
+            atrMeasurement.add({
+                navigateCallbackResult: navigate !== false,
+            });
+            atrMeasurement.event =
+                atrMeasurement.end({ success: true }) || atrMeasurement.event;
+            return navigate;
+        };
         try {
             redirectPreflightCheck(this.initialized, this.config);
             this.browserStorage.setInteractionInProgress(true, INTERACTION_TYPE.SIGNIN);
-            if (isLoggedIn) {
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Redirect, request);
-            }
-            else {
-                this.eventHandler.emitEvent(EventType.LOGIN_START, InteractionType.Redirect, request);
-            }
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Redirect, request);
             let result;
             if (this.platformAuthProvider &&
                 this.canUsePlatformBroker(request)) {
@@ -363,18 +342,14 @@ class StandardController {
                 result = nativeClient
                     .acquireTokenRedirect(request, atrMeasurement)
                     .catch((e) => {
-                    atrMeasurement.add({
-                        brokerErrorName: e.name,
-                        brokerErrorCode: e.errorCode,
-                    });
                     if (e instanceof NativeAuthError &&
                         isFatalNativeAuthError(e)) {
-                        this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt platform broker calls
+                        this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt
                         const redirectClient = this.createRedirectClient(correlationId);
                         return redirectClient.acquireToken(request);
                     }
                     else if (e instanceof InteractionRequiredAuthError) {
-                        this.logger.verbose("acquireTokenRedirect - Resolving interaction required error thrown by native broker by falling back to web flow");
+                        this.logger.verbose("acquireTokenRedirect - Resolving interaction required error thrown by native broker by falling back to web flow", correlationId);
                         const redirectClient = this.createRedirectClient(correlationId);
                         return redirectClient.acquireToken(request);
                     }
@@ -388,25 +363,20 @@ class StandardController {
             return await result;
         }
         catch (e) {
-            this.browserStorage.resetRequestCache();
+            this.browserStorage.resetRequestCache(correlationId);
             /*
              * Pre-redirect event completes before navigation occurs.
              * Timed out navigation needs to be instrumented separately as a post-redirect event.
              */
             if (atrMeasurement.event.status === 2) {
                 this.performanceClient
-                    .startMeasurement(PerformanceEvents.AcquireTokenRedirect, correlationId)
-                    .end({ success: false }, e, request.account);
+                    .startMeasurement(AcquireTokenRedirect, correlationId)
+                    .end({ success: false }, e);
             }
             else {
-                atrMeasurement.end({ success: false }, e, request.account);
-            }
-            if (isLoggedIn) {
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Redirect, null, e);
-            }
-            else {
-                this.eventHandler.emitEvent(EventType.LOGIN_FAILURE, InteractionType.Redirect, null, e);
+                atrMeasurement.end({ success: false }, e);
             }
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Redirect, null, e);
             throw e;
         }
     }
@@ -421,13 +391,14 @@ class StandardController {
      */
     acquireTokenPopup(request) {
         const correlationId = this.getRequestCorrelationId(request);
-        const atPopupMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenPopup, correlationId);
+        const atPopupMeasurement = this.performanceClient.startMeasurement(AcquireTokenPopup, correlationId);
         atPopupMeasurement.add({
             scenarioId: request.scenarioId,
+            accountType: getAccountType(request.account),
         });
         try {
             this.logger.verbose("acquireTokenPopup called", correlationId);
-            preflightCheck(this.initialized, atPopupMeasurement, request.account);
+            preflightCheck(this.initialized, atPopupMeasurement);
             this.browserStorage.setInteractionInProgress(true, INTERACTION_TYPE.SIGNIN);
         }
         catch (e) {
@@ -436,18 +407,10 @@ class StandardController {
         }
         // If logged in, emit acquire token events
         const loggedInAccounts = this.getAllAccounts();
-        if (loggedInAccounts.length > 0) {
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Popup, request);
-        }
-        else {
-            this.eventHandler.emitEvent(EventType.LOGIN_START, InteractionType.Popup, request);
-        }
+        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Popup, request);
         let result;
         const pkce = this.getPreGeneratedPkceCodes(correlationId);
         if (this.canUsePlatformBroker(request)) {
-            atPopupMeasurement.add({
-                isPlatformBrokerRequest: true,
-            });
             result = this.acquireTokenNative({
                 ...request,
                 correlationId,
@@ -455,22 +418,20 @@ class StandardController {
                 .then((response) => {
                 atPopupMeasurement.end({
                     success: true,
-                }, undefined, response.account);
+                    isNativeBroker: true,
+                    accountType: getAccountType(response.account),
+                });
                 return response;
             })
                 .catch((e) => {
-                atPopupMeasurement.add({
-                    brokerErrorName: e.name,
-                    brokerErrorCode: e.errorCode,
-                });
                 if (e instanceof NativeAuthError &&
                     isFatalNativeAuthError(e)) {
-                    this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to continuing to attempt platform broker calls
+                    this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt
                     const popupClient = this.createPopupClient(correlationId);
                     return popupClient.acquireToken(request, pkce);
                 }
                 else if (e instanceof InteractionRequiredAuthError) {
-                    this.logger.verbose("acquireTokenPopup - Resolving interaction required error thrown by native broker by falling back to web flow");
+                    this.logger.verbose("acquireTokenPopup - Resolving interaction required error thrown by native broker by falling back to web flow", correlationId);
                     const popupClient = this.createPopupClient(correlationId);
                     return popupClient.acquireToken(request, pkce);
                 }
@@ -487,35 +448,29 @@ class StandardController {
              *  If logged in, emit acquire token events
              */
             const isLoggingIn = loggedInAccounts.length < this.getAllAccounts().length;
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Popup, result);
             if (isLoggingIn) {
-                this.eventHandler.emitEvent(EventType.LOGIN_SUCCESS, InteractionType.Popup, result);
-            }
-            else {
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Popup, result);
+                this.eventHandler.emitEvent(EventType.LOGIN_SUCCESS, InteractionType.Popup, result.account);
             }
             atPopupMeasurement.end({
                 success: true,
                 accessTokenSize: result.accessToken.length,
                 idTokenSize: result.idToken.length,
-            }, undefined, result.account);
+                accountType: getAccountType(result.account),
+            });
             return result;
         })
             .catch((e) => {
-            if (loggedInAccounts.length > 0) {
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Popup, null, e);
-            }
-            else {
-                this.eventHandler.emitEvent(EventType.LOGIN_FAILURE, InteractionType.Popup, null, e);
-            }
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Popup, null, e);
             atPopupMeasurement.end({
                 success: false,
-            }, e, request.account);
+            }, e);
             // Since this function is syncronous we need to reject
             return Promise.reject(e);
         })
             .finally(async () => {
             this.browserStorage.setInteractionInProgress(false);
-            if (this.config.system.asyncPopups) {
+            if (!this.config.system.navigatePopups) {
                 await this.preGeneratePkceCodes(correlationId);
             }
         });
@@ -526,7 +481,6 @@ class StandardController {
         if (!measurement) {
             return;
         }
-        this.logger.info("Perf: Visibility change detected in ", measurement.event.name);
         measurement.increment({
             visibilityChangeCount: 1,
         });
@@ -556,27 +510,22 @@ class StandardController {
             prompt: request.prompt,
             correlationId: correlationId,
         };
-        this.ssoSilentMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.SsoSilent, correlationId);
+        this.ssoSilentMeasurement = this.performanceClient.startMeasurement(SsoSilent, correlationId);
         this.ssoSilentMeasurement?.add({
             scenarioId: request.scenarioId,
+            accountType: getAccountType(request.account),
         });
-        preflightCheck(this.initialized, this.ssoSilentMeasurement, request.account);
+        preflightCheck(this.initialized, this.ssoSilentMeasurement);
         this.ssoSilentMeasurement?.increment({
             visibilityChangeCount: 0,
         });
         document.addEventListener("visibilitychange", this.trackPageVisibilityWithMeasurement);
+        const loggedInAccounts = this.getAllAccounts();
         this.logger.verbose("ssoSilent called", correlationId);
-        this.eventHandler.emitEvent(EventType.SSO_SILENT_START, InteractionType.Silent, validRequest);
+        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Silent, validRequest);
         let result;
         if (this.canUsePlatformBroker(validRequest)) {
-            this.ssoSilentMeasurement?.add({
-                isPlatformBrokerRequest: true,
-            });
             result = this.acquireTokenNative(validRequest, ApiId.ssoSilent).catch((e) => {
-                this.ssoSilentMeasurement?.add({
-                    brokerErrorName: e.name,
-                    brokerErrorCode: e.errorCode,
-                });
                 // If native token acquisition fails for availability reasons fallback to standard flow
                 if (e instanceof NativeAuthError && isFatalNativeAuthError(e)) {
                     this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt
@@ -592,19 +541,25 @@ class StandardController {
         }
         return result
             .then((response) => {
-            this.eventHandler.emitEvent(EventType.SSO_SILENT_SUCCESS, InteractionType.Silent, response);
+            const isLoggingIn = loggedInAccounts.length < this.getAllAccounts().length;
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Silent, response);
+            if (isLoggingIn) {
+                this.eventHandler.emitEvent(EventType.LOGIN_SUCCESS, InteractionType.Silent, response.account);
+            }
             this.ssoSilentMeasurement?.end({
                 success: true,
+                isNativeBroker: response.fromPlatformBroker,
                 accessTokenSize: response.accessToken.length,
                 idTokenSize: response.idToken.length,
-            }, undefined, response.account);
+                accountType: getAccountType(response.account),
+            });
             return response;
         })
             .catch((e) => {
-            this.eventHandler.emitEvent(EventType.SSO_SILENT_FAILURE, InteractionType.Silent, null, e);
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Silent, null, e);
             this.ssoSilentMeasurement?.end({
                 success: false,
-            }, e, request.account);
+            }, e);
             throw e;
         })
             .finally(() => {
@@ -624,9 +579,9 @@ class StandardController {
     async acquireTokenByCode(request) {
         const correlationId = this.getRequestCorrelationId(request);
         this.logger.trace("acquireTokenByCode called", correlationId);
-        const atbcMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenByCode, correlationId);
+        const atbcMeasurement = this.performanceClient.startMeasurement(AcquireTokenByCode, correlationId);
         preflightCheck(this.initialized, atbcMeasurement);
-        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_START, InteractionType.Silent, request);
+        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Silent, request);
         atbcMeasurement.add({ scenarioId: request.scenarioId });
         try {
             if (request.code && request.nativeAccountId) {
@@ -643,18 +598,20 @@ class StandardController {
                         correlationId,
                     })
                         .then((result) => {
-                        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_SUCCESS, InteractionType.Silent, result);
+                        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Silent, result);
                         this.hybridAuthCodeResponses.delete(hybridAuthCode);
                         atbcMeasurement.end({
                             success: true,
+                            isNativeBroker: result.fromPlatformBroker,
                             accessTokenSize: result.accessToken.length,
                             idTokenSize: result.idToken.length,
-                        }, undefined, result.account);
+                            accountType: getAccountType(result.account),
+                        });
                         return result;
                     })
                         .catch((error) => {
                         this.hybridAuthCodeResponses.delete(hybridAuthCode);
-                        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE, InteractionType.Silent, null, error);
+                        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Silent, null, error);
                         atbcMeasurement.end({
                             success: false,
                         }, error);
@@ -670,9 +627,6 @@ class StandardController {
             }
             else if (request.nativeAccountId) {
                 if (this.canUsePlatformBroker(request, request.nativeAccountId)) {
-                    atbcMeasurement.add({
-                        isPlatformBrokerRequest: true,
-                    });
                     const result = await this.acquireTokenNative({
                         ...request,
                         correlationId,
@@ -682,15 +636,12 @@ class StandardController {
                             isFatalNativeAuthError(e)) {
                             this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt
                         }
-                        atbcMeasurement.add({
-                            brokerErrorName: e.name,
-                            brokerErrorCode: e.errorCode,
-                        });
                         throw e;
                     });
                     atbcMeasurement.end({
+                        accountType: getAccountType(result.account),
                         success: true,
-                    }, undefined, result.account);
+                    });
                     return result;
                 }
                 else {
@@ -702,7 +653,7 @@ class StandardController {
             }
         }
         catch (e) {
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE, InteractionType.Silent, null, e);
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Silent, null, e);
             atbcMeasurement.end({
                 success: false,
             }, e);
@@ -715,20 +666,22 @@ class StandardController {
      * @returns Result of the operation to redeem the authorization code
      */
     async acquireTokenByCodeAsync(request) {
-        this.logger.trace("acquireTokenByCodeAsync called", request.correlationId);
+        const correlationId = this.getRequestCorrelationId(request);
+        this.logger.trace("acquireTokenByCodeAsync called", correlationId);
         this.acquireTokenByCodeAsyncMeasurement =
-            this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenByCodeAsync, request.correlationId);
+            this.performanceClient.startMeasurement(AcquireTokenByCodeAsync, correlationId);
         this.acquireTokenByCodeAsyncMeasurement?.increment({
             visibilityChangeCount: 0,
         });
         document.addEventListener("visibilitychange", this.trackPageVisibilityWithMeasurement);
-        const silentAuthCodeClient = this.createSilentAuthCodeClient(request.correlationId);
+        const silentAuthCodeClient = this.createSilentAuthCodeClient(correlationId);
         const silentTokenResult = await silentAuthCodeClient
             .acquireToken(request)
             .then((response) => {
             this.acquireTokenByCodeAsyncMeasurement?.end({
                 success: true,
                 fromCache: response.fromCache,
+                isNativeBroker: response.fromPlatformBroker,
             });
             return response;
         })
@@ -751,13 +704,12 @@ class StandardController {
      * @returns A promise that, when resolved, returns the access token
      */
     async acquireTokenFromCache(commonRequest, cacheLookupPolicy) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.AcquireTokenFromCache, commonRequest.correlationId);
         switch (cacheLookupPolicy) {
             case CacheLookupPolicy.Default:
             case CacheLookupPolicy.AccessToken:
             case CacheLookupPolicy.AccessTokenAndRefreshToken:
                 const silentCacheClient = this.createSilentCacheClient(commonRequest.correlationId);
-                return invokeAsync(silentCacheClient.acquireToken.bind(silentCacheClient), PerformanceEvents.SilentCacheClientAcquireToken, this.logger, this.performanceClient, commonRequest.correlationId)(commonRequest);
+                return invokeAsync(silentCacheClient.acquireToken.bind(silentCacheClient), SilentCacheClientAcquireToken, this.logger, this.performanceClient, commonRequest.correlationId)(commonRequest);
             default:
                 throw createClientAuthError(ClientAuthErrorCodes.tokenRefreshRequired);
         }
@@ -769,14 +721,13 @@ class StandardController {
      * @returns A promise that, when resolved, returns the access token
      */
     async acquireTokenByRefreshToken(commonRequest, cacheLookupPolicy) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.AcquireTokenByRefreshToken, commonRequest.correlationId);
         switch (cacheLookupPolicy) {
             case CacheLookupPolicy.Default:
             case CacheLookupPolicy.AccessTokenAndRefreshToken:
             case CacheLookupPolicy.RefreshToken:
             case CacheLookupPolicy.RefreshTokenAndNetwork:
                 const silentRefreshClient = this.createSilentRefreshClient(commonRequest.correlationId);
-                return invokeAsync(silentRefreshClient.acquireToken.bind(silentRefreshClient), PerformanceEvents.SilentRefreshClientAcquireToken, this.logger, this.performanceClient, commonRequest.correlationId)(commonRequest);
+                return invokeAsync(silentRefreshClient.acquireToken.bind(silentRefreshClient), SilentRefreshClientAcquireToken, this.logger, this.performanceClient, commonRequest.correlationId)(commonRequest);
             default:
                 throw createClientAuthError(ClientAuthErrorCodes.tokenRefreshRequired);
         }
@@ -787,25 +738,11 @@ class StandardController {
      * @returns A promise that, when resolved, returns the access token
      */
     async acquireTokenBySilentIframe(request) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.AcquireTokenBySilentIframe, request.correlationId);
         const silentIframeClient = this.createSilentIframeClient(request.correlationId);
-        return invokeAsync(silentIframeClient.acquireToken.bind(silentIframeClient), PerformanceEvents.SilentIframeClientAcquireToken, this.logger, this.performanceClient, request.correlationId)(request);
+        return invokeAsync(silentIframeClient.acquireToken.bind(silentIframeClient), SilentIframeClientAcquireToken, this.logger, this.performanceClient, request.correlationId)(request);
     }
     // #endregion
     // #region Logout
-    /**
-     * Deprecated logout function. Use logoutRedirect or logoutPopup instead
-     * @param logoutRequest
-     * @deprecated
-     */
-    async logout(logoutRequest) {
-        const correlationId = this.getRequestCorrelationId(logoutRequest);
-        this.logger.warning("logout API is deprecated and will be removed in msal-browser v3.0.0. Use logoutRedirect instead.", correlationId);
-        return this.logoutRedirect({
-            correlationId,
-            ...logoutRequest,
-        });
-    }
     /**
      * Use to log out the current user, and redirect the user to the postLogoutRedirectUri.
      * Default behaviour is to redirect the user to `window.location.href`.
@@ -843,7 +780,6 @@ class StandardController {
      */
     async clearCache(logoutRequest) {
         if (!this.isBrowserEnvironment) {
-            this.logger.info("in non-browser environment, returning early.");
             return;
         }
         const correlationId = this.getRequestCorrelationId(logoutRequest);
@@ -858,8 +794,7 @@ class StandardController {
      * @returns Array of AccountInfo objects in cache
      */
     getAllAccounts(accountFilter) {
-        const correlationId = this.getRequestCorrelationId();
-        return getAllAccounts(this.logger, this.browserStorage, this.isBrowserEnvironment, correlationId, accountFilter);
+        return getAllAccounts(this.logger, this.browserStorage, this.isBrowserEnvironment, this.getRequestCorrelationId(), accountFilter);
     }
     /**
      * Returns the first account found in the cache that matches the account filter passed in.
@@ -867,8 +802,7 @@ class StandardController {
      * @returns The first account found in the cache matching the provided filter or null if no account could be found.
      */
     getAccount(accountFilter) {
-        const correlationId = this.getRequestCorrelationId();
-        return getAccount(accountFilter, this.logger, this.browserStorage, correlationId);
+        return getAccount(accountFilter, this.logger, this.browserStorage, this.getRequestCorrelationId());
     }
     /**
      * Returns the signed in account matching username.
@@ -879,8 +813,7 @@ class StandardController {
      * @returns The account object stored in MSAL
      */
     getAccountByUsername(username) {
-        const correlationId = this.getRequestCorrelationId();
-        return getAccountByUsername(username, this.logger, this.browserStorage, correlationId);
+        return getAccountByUsername(username, this.logger, this.browserStorage, this.getRequestCorrelationId());
     }
     /**
      * Returns the signed in account matching homeAccountId.
@@ -890,8 +823,7 @@ class StandardController {
      * @returns The account object stored in MSAL
      */
     getAccountByHomeId(homeAccountId) {
-        const correlationId = this.getRequestCorrelationId();
-        return getAccountByHomeId(homeAccountId, this.logger, this.browserStorage, correlationId);
+        return getAccountByHomeId(homeAccountId, this.logger, this.browserStorage, this.getRequestCorrelationId());
     }
     /**
      * Returns the signed in account matching localAccountId.
@@ -901,23 +833,20 @@ class StandardController {
      * @returns The account object stored in MSAL
      */
     getAccountByLocalId(localAccountId) {
-        const correlationId = this.getRequestCorrelationId();
-        return getAccountByLocalId(localAccountId, this.logger, this.browserStorage, correlationId);
+        return getAccountByLocalId(localAccountId, this.logger, this.browserStorage, this.getRequestCorrelationId());
     }
     /**
      * Sets the account to use as the active account. If no account is passed to the acquireToken APIs, then MSAL will use this active account.
      * @param account
      */
     setActiveAccount(account) {
-        const correlationId = this.getRequestCorrelationId();
-        setActiveAccount(account, this.browserStorage, correlationId);
+        setActiveAccount(account, this.browserStorage, this.getRequestCorrelationId());
     }
     /**
      * Gets the currently active account
      */
     getActiveAccount() {
-        const correlationId = this.getRequestCorrelationId();
-        return getActiveAccount(this.browserStorage, correlationId);
+        return getActiveAccount(this.browserStorage, this.getRequestCorrelationId());
     }
     // #endregion
     /**
@@ -927,12 +856,12 @@ class StandardController {
      * @returns
      */
     async hydrateCache(result, request) {
-        this.logger.verbose("hydrateCache called");
+        this.logger.verbose("hydrateCache called", result.correlationId);
         // Account gets saved to browser storage regardless of native or not
-        const accountEntity = AccountEntity.createFromAccountInfo(result.account, result.cloudGraphHostName, result.msGraphHost);
+        const accountEntity = AccountEntityUtils.createAccountEntityFromAccountInfo(result.account, result.cloudGraphHostName, result.msGraphHost);
         await this.browserStorage.setAccount(accountEntity, result.correlationId);
-        if (result.fromNativeBroker) {
-            this.logger.verbose("Response was from native broker, storing in-memory");
+        if (result.fromPlatformBroker) {
+            this.logger.verbose("Response was from native broker, storing in-memory", result.correlationId);
             // Tokens from native broker are stored in-memory
             return this.nativeInternalStorage.hydrateCache(result, request);
         }
@@ -946,11 +875,12 @@ class StandardController {
      * @param request
      */
     async acquireTokenNative(request, apiId, accountId, cacheLookupPolicy) {
-        this.logger.trace("acquireTokenNative called");
+        const correlationId = this.getRequestCorrelationId(request);
+        this.logger.trace("acquireTokenNative called", correlationId);
         if (!this.platformAuthProvider) {
             throw createBrowserAuthError(nativeConnectionNotEstablished);
         }
-        const nativeClient = new PlatformAuthInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, apiId, this.performanceClient, this.platformAuthProvider, accountId || this.getNativeAccountId(request), this.nativeInternalStorage, request.correlationId);
+        const nativeClient = new PlatformAuthInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, apiId, this.performanceClient, this.platformAuthProvider, accountId || this.getNativeAccountId(request), this.nativeInternalStorage, correlationId);
         return nativeClient.acquireToken(request, cacheLookupPolicy);
     }
     /**
@@ -958,29 +888,30 @@ class StandardController {
      * @param request
      */
     canUsePlatformBroker(request, accountId) {
-        this.logger.trace("canUsePlatformBroker called");
+        const correlationId = this.getRequestCorrelationId(request);
+        this.logger.trace("canUsePlatformBroker called", correlationId);
         if (!this.platformAuthProvider) {
-            this.logger.trace("canUsePlatformBroker: platform broker unavilable, returning false");
+            this.logger.trace("canUsePlatformBroker: platform broker unavilable, returning false", correlationId);
             return false;
         }
-        if (!isPlatformAuthAllowed(this.config, this.logger, this.platformAuthProvider, request.authenticationScheme)) {
-            this.logger.trace("canUsePlatformBroker: isBrokerAvailable returned false, returning false");
+        if (!isPlatformAuthAllowed(this.config, this.logger, correlationId, this.platformAuthProvider, request.authenticationScheme)) {
+            this.logger.trace("canUsePlatformBroker: isBrokerAvailable returned false, returning false", correlationId);
             return false;
         }
         if (request.prompt) {
             switch (request.prompt) {
-                case PromptValue.NONE:
-                case PromptValue.CONSENT:
-                case PromptValue.LOGIN:
-                    this.logger.trace("canUsePlatformBroker: prompt is compatible with platform broker flow");
+                case Constants.PromptValue.NONE:
+                case Constants.PromptValue.CONSENT:
+                case Constants.PromptValue.LOGIN:
+                    this.logger.trace("canUsePlatformBroker: prompt is compatible with platform broker flow", correlationId);
                     break;
                 default:
-                    this.logger.trace(`canUsePlatformBroker: prompt = ${request.prompt} is not compatible with platform broker flow, returning false`);
+                    this.logger.trace(`canUsePlatformBroker: prompt = '${request.prompt}' is not compatible with platform broker flow, returning false`, correlationId);
                     return false;
             }
         }
         if (!accountId && !this.getNativeAccountId(request)) {
-            this.logger.trace("canUsePlatformBroker: nativeAccountId is not available, returning false");
+            this.logger.trace("canUsePlatformBroker: nativeAccountId is not available, returning false", correlationId);
             return false;
         }
         return true;
@@ -1004,39 +935,39 @@ class StandardController {
      * @param correlationId
      */
     createPopupClient(correlationId) {
-        return new PopupClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeInternalStorage, this.platformAuthProvider, correlationId);
+        return new PopupClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeInternalStorage, correlationId, this.platformAuthProvider);
     }
     /**
      * Returns new instance of the Redirect Interaction Client
      * @param correlationId
      */
     createRedirectClient(correlationId) {
-        return new RedirectClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeInternalStorage, this.platformAuthProvider, correlationId);
+        return new RedirectClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeInternalStorage, correlationId, this.platformAuthProvider);
     }
     /**
      * Returns new instance of the Silent Iframe Interaction Client
      * @param correlationId
      */
     createSilentIframeClient(correlationId) {
-        return new SilentIframeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.ssoSilent, this.performanceClient, this.nativeInternalStorage, this.platformAuthProvider, correlationId);
+        return new SilentIframeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.ssoSilent, this.performanceClient, this.nativeInternalStorage, correlationId, this.platformAuthProvider);
     }
     /**
      * Returns new instance of the Silent Cache Interaction Client
      */
     createSilentCacheClient(correlationId) {
-        return new SilentCacheClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.platformAuthProvider, correlationId);
+        return new SilentCacheClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, correlationId, this.platformAuthProvider);
     }
     /**
      * Returns new instance of the Silent Refresh Interaction Client
      */
     createSilentRefreshClient(correlationId) {
-        return new SilentRefreshClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.platformAuthProvider, correlationId);
+        return new SilentRefreshClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, correlationId, this.platformAuthProvider);
     }
     /**
      * Returns new instance of the Silent AuthCode Interaction Client
      */
     createSilentAuthCodeClient(correlationId) {
-        return new SilentAuthCodeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.acquireTokenByCode, this.performanceClient, this.platformAuthProvider, correlationId);
+        return new SilentAuthCodeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.acquireTokenByCode, this.performanceClient, correlationId, this.platformAuthProvider);
     }
     /**
      * Adds event callbacks to array
@@ -1071,36 +1002,6 @@ class StandardController {
     removePerformanceCallback(callbackId) {
         return this.performanceClient.removePerformanceCallback(callbackId);
     }
-    /**
-     * Adds event listener that emits an event when a user account is added or removed from localstorage in a different browser tab or window
-     * @deprecated These events will be raised by default and this method will be removed in a future major version.
-     */
-    enableAccountStorageEvents() {
-        if (this.config.cache.cacheLocation !==
-            BrowserCacheLocation.LocalStorage) {
-            this.logger.info("Account storage events are only available when cacheLocation is set to localStorage");
-            return;
-        }
-        this.eventHandler.subscribeCrossTab();
-    }
-    /**
-     * Removes event listener that emits an event when a user account is added or removed from localstorage in a different browser tab or window
-     * @deprecated These events will be raised by default and this method will be removed in a future major version.
-     */
-    disableAccountStorageEvents() {
-        if (this.config.cache.cacheLocation !==
-            BrowserCacheLocation.LocalStorage) {
-            this.logger.info("Account storage events are only available when cacheLocation is set to localStorage");
-            return;
-        }
-        this.eventHandler.unsubscribeCrossTab();
-    }
-    /**
-     * Gets the token cache for the application.
-     */
-    getTokenCache() {
-        return this.tokenCache;
-    }
     /**
      * Returns the logger instance
      */
@@ -1166,7 +1067,7 @@ class StandardController {
          * Included for fallback for non-browser environments,
          * and to ensure this method always returns a string.
          */
-        return Constants.EMPTY_STRING;
+        return "";
     }
     // #endregion
     /**
@@ -1209,25 +1110,27 @@ class StandardController {
      */
     async acquireTokenSilent(request) {
         const correlationId = this.getRequestCorrelationId(request);
-        const atsMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenSilent, correlationId);
+        const atsMeasurement = this.performanceClient.startMeasurement(AcquireTokenSilent, correlationId);
         atsMeasurement.add({
             cacheLookupPolicy: request.cacheLookupPolicy,
             scenarioId: request.scenarioId,
         });
-        preflightCheck(this.initialized, atsMeasurement, request.account);
+        preflightCheck(this.initialized, atsMeasurement);
         this.logger.verbose("acquireTokenSilent called", correlationId);
         const account = request.account || this.getActiveAccount();
         if (!account) {
             throw createBrowserAuthError(noAccountError);
         }
+        atsMeasurement.add({ accountType: getAccountType(account) });
         return this.acquireTokenSilentDeduped(request, account, correlationId)
             .then((result) => {
             atsMeasurement.end({
                 success: true,
                 fromCache: result.fromCache,
+                isNativeBroker: result.fromPlatformBroker,
                 accessTokenSize: result.accessToken.length,
                 idTokenSize: result.idToken.length,
-            }, undefined, result.account);
+            });
             return {
                 ...result,
                 state: request.state,
@@ -1241,7 +1144,7 @@ class StandardController {
             }
             atsMeasurement.end({
                 success: false,
-            }, error, account);
+            }, error);
             throw error;
         });
     }
@@ -1263,7 +1166,7 @@ class StandardController {
         if (typeof inProgressRequest === "undefined") {
             this.logger.verbose("acquireTokenSilent called for the first time, storing active request", correlationId);
             this.performanceClient.addFields({ deduped: false }, correlationId);
-            const activeRequest = invokeAsync(this.acquireTokenSilentAsync.bind(this), PerformanceEvents.AcquireTokenSilentAsync, this.logger, this.performanceClient, correlationId)({
+            const activeRequest = invokeAsync(this.acquireTokenSilentAsync.bind(this), AcquireTokenSilentAsync, this.logger, this.performanceClient, correlationId)({
                 ...request,
                 correlationId,
             }, account);
@@ -1286,13 +1189,12 @@ class StandardController {
      */
     async acquireTokenSilentAsync(request, account) {
         const trackPageVisibility = () => this.trackPageVisibility(request.correlationId);
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.AcquireTokenSilentAsync, request.correlationId);
         this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Silent, request);
         if (request.correlationId) {
             this.performanceClient.incrementFields({ visibilityChangeCount: 0 }, request.correlationId);
         }
         document.addEventListener("visibilitychange", trackPageVisibility);
-        const silentRequest = await invokeAsync(initializeSilentRequest, PerformanceEvents.InitializeSilentRequest, this.logger, this.performanceClient, request.correlationId)(request, account, this.config, this.performanceClient, this.logger);
+        const silentRequest = await invokeAsync(initializeSilentRequest, InitializeSilentRequest, this.logger, this.performanceClient, request.correlationId)(request, account, this.config, this.performanceClient, this.logger);
         const cacheLookupPolicy = request.cacheLookupPolicy || CacheLookupPolicy.Default;
         const result = this.acquireTokenSilentNoIframe(silentRequest, cacheLookupPolicy).catch(async (refreshTokenError) => {
             const shouldTryToResolveSilently = checkIfRefreshTokenErrorCanBeResolvedSilently(refreshTokenError, cacheLookupPolicy);
@@ -1307,7 +1209,7 @@ class StandardController {
                         silentRequest.correlationId,
                     ];
                     this.logger.verbose("Refresh token expired/invalid or CacheLookupPolicy is set to Skip, attempting acquire token by iframe.", silentRequest.correlationId);
-                    return invokeAsync(this.acquireTokenBySilentIframe.bind(this), PerformanceEvents.AcquireTokenBySilentIframe, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest)
+                    return invokeAsync(this.acquireTokenBySilentIframe.bind(this), AcquireTokenBySilentIframe, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest)
                         .then((iframeResult) => {
                         _resolve(true);
                         return iframeResult;
@@ -1322,8 +1224,8 @@ class StandardController {
                 }
                 else if (cacheLookupPolicy !== CacheLookupPolicy.Skip) {
                     const [activePromise, activeCorrelationId] = this.activeIframeRequest;
-                    this.logger.verbose(`Iframe request is already in progress, awaiting resolution for request with correlationId: ${activeCorrelationId}`, silentRequest.correlationId);
-                    const awaitConcurrentIframeMeasure = this.performanceClient.startMeasurement(PerformanceEvents.AwaitConcurrentIframe, silentRequest.correlationId);
+                    this.logger.verbose(`Iframe request is already in progress, awaiting resolution for request with correlationId: '${activeCorrelationId}'`, silentRequest.correlationId);
+                    const awaitConcurrentIframeMeasure = this.performanceClient.startMeasurement(AwaitConcurrentIframe, silentRequest.correlationId);
                     awaitConcurrentIframeMeasure.add({
                         awaitIframeCorrelationId: activeCorrelationId,
                     });
@@ -1332,12 +1234,12 @@ class StandardController {
                         success: activePromiseResult,
                     });
                     if (activePromiseResult) {
-                        this.logger.verbose(`Parallel iframe request with correlationId: ${activeCorrelationId} succeeded. Retrying cache and/or RT redemption`, silentRequest.correlationId);
+                        this.logger.verbose(`Parallel iframe request with correlationId: '${activeCorrelationId}' succeeded. Retrying cache and/or RT redemption`, silentRequest.correlationId);
                         // Retry cache lookup and/or RT exchange after iframe completes
                         return this.acquireTokenSilentNoIframe(silentRequest, cacheLookupPolicy);
                     }
                     else {
-                        this.logger.info(`Iframe request with correlationId: ${activeCorrelationId} failed. Interaction is required.`);
+                        this.logger.info(`Iframe request with correlationId: '${activeCorrelationId}' failed. Interaction is required.`, silentRequest.correlationId);
                         // If previous iframe request failed, it's unlikely to succeed this time. Throw original error.
                         throw refreshTokenError;
                     }
@@ -1345,7 +1247,7 @@ class StandardController {
                 else {
                     // Cache policy set to skip and another iframe request is already in progress
                     this.logger.warning("Another iframe request is currently in progress and CacheLookupPolicy is set to Skip. This may result in degraded performance and/or reliability for both calls. Please consider changing the CacheLookupPolicy to take advantage of request queuing and token cache.", silentRequest.correlationId);
-                    return invokeAsync(this.acquireTokenBySilentIframe.bind(this), PerformanceEvents.AcquireTokenBySilentIframe, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest);
+                    return invokeAsync(this.acquireTokenBySilentIframe.bind(this), AcquireTokenBySilentIframe, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest);
                 }
             }
             else {
@@ -1356,9 +1258,12 @@ class StandardController {
         return result
             .then((response) => {
             this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Silent, response);
-            this.performanceClient.addFields({
-                fromCache: response.fromCache,
-            }, request.correlationId);
+            if (request.correlationId) {
+                this.performanceClient.addFields({
+                    fromCache: response.fromCache,
+                    isNativeBroker: response.fromPlatformBroker,
+                }, request.correlationId);
+            }
             return response;
         })
             .catch((tokenRenewalError) => {
@@ -1377,18 +1282,13 @@ class StandardController {
      */
     async acquireTokenSilentNoIframe(silentRequest, cacheLookupPolicy) {
         // if the cache policy is set to access_token only, we should not be hitting the native layer yet
-        if (isPlatformAuthAllowed(this.config, this.logger, this.platformAuthProvider, silentRequest.authenticationScheme) &&
+        if (isPlatformAuthAllowed(this.config, this.logger, silentRequest.correlationId, this.platformAuthProvider, silentRequest.authenticationScheme) &&
             silentRequest.account.nativeAccountId) {
-            this.logger.verbose("acquireTokenSilent - attempting to acquire token from native platform");
-            this.performanceClient.addFields({ isPlatformBrokerRequest: true }, silentRequest.correlationId);
+            this.logger.verbose("acquireTokenSilent - attempting to acquire token from native platform", silentRequest.correlationId);
             return this.acquireTokenNative(silentRequest, ApiId.acquireTokenSilent_silentFlow, silentRequest.account.nativeAccountId, cacheLookupPolicy).catch(async (e) => {
-                this.performanceClient.addFields({
-                    brokerErrorName: e.name,
-                    brokerErrorCode: e.errorCode,
-                }, silentRequest.correlationId);
                 // If native token acquisition fails for availability reasons fallback to web flow
                 if (e instanceof NativeAuthError && isFatalNativeAuthError(e)) {
-                    this.logger.verbose("acquireTokenSilent - native platform unavailable, falling back to web flow");
+                    this.logger.verbose("acquireTokenSilent - native platform unavailable, falling back to web flow", silentRequest.correlationId);
                     this.platformAuthProvider = undefined; // Prevent future requests from continuing to attempt
                     // Cache will not contain tokens, given that previous WAM requests succeeded. Skip cache and RT renewal and go straight to iframe renewal
                     throw createClientAuthError(ClientAuthErrorCodes.tokenRefreshRequired);
@@ -1397,17 +1297,17 @@ class StandardController {
             });
         }
         else {
-            this.logger.verbose("acquireTokenSilent - attempting to acquire token from web flow");
+            this.logger.verbose("acquireTokenSilent - attempting to acquire token from web flow", silentRequest.correlationId);
             // add logs to identify embedded cache retrieval
             if (cacheLookupPolicy === CacheLookupPolicy.AccessToken) {
-                this.logger.verbose("acquireTokenSilent - cache lookup policy set to AccessToken, attempting to acquire token from local cache");
+                this.logger.verbose("acquireTokenSilent - cache lookup policy set to AccessToken, attempting to acquire token from local cache", silentRequest.correlationId);
             }
-            return invokeAsync(this.acquireTokenFromCache.bind(this), PerformanceEvents.AcquireTokenFromCache, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest, cacheLookupPolicy).catch((cacheError) => {
+            return invokeAsync(this.acquireTokenFromCache.bind(this), AcquireTokenFromCache, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest, cacheLookupPolicy).catch((cacheError) => {
                 if (cacheLookupPolicy === CacheLookupPolicy.AccessToken) {
                     throw cacheError;
                 }
                 this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_NETWORK_START, InteractionType.Silent, silentRequest);
-                return invokeAsync(this.acquireTokenByRefreshToken.bind(this), PerformanceEvents.AcquireTokenByRefreshToken, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest, cacheLookupPolicy);
+                return invokeAsync(this.acquireTokenByRefreshToken.bind(this), AcquireTokenByRefreshToken, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest, cacheLookupPolicy);
             });
         }
     }
@@ -1416,8 +1316,8 @@ class StandardController {
      * @param correlationId
      */
     async preGeneratePkceCodes(correlationId) {
-        this.logger.verbose("Generating new PKCE codes");
-        this.pkceCode = await invokeAsync(generatePkceCodes, PerformanceEvents.GeneratePkceCodes, this.logger, this.performanceClient, correlationId)(this.performanceClient, this.logger, correlationId);
+        this.logger.verbose("Generating new PKCE codes", correlationId);
+        this.pkceCode = await invokeAsync(generatePkceCodes, GeneratePkceCodes, this.logger, this.performanceClient, correlationId)(this.performanceClient, this.logger, correlationId);
         return Promise.resolve();
     }
     /**
@@ -1425,14 +1325,14 @@ class StandardController {
      * @param correlationId
      */
     getPreGeneratedPkceCodes(correlationId) {
-        this.logger.verbose("Attempting to pick up pre-generated PKCE codes");
+        this.logger.verbose("Attempting to pick up pre-generated PKCE codes", correlationId);
         const res = this.pkceCode ? { ...this.pkceCode } : undefined;
         this.pkceCode = undefined;
-        this.logger.verbose(`${res ? "Found" : "Did not find"} pre-generated PKCE codes`);
+        this.logger.verbose(`'${res ? "Found" : "Did not find"}' pre-generated PKCE codes`, correlationId);
         this.performanceClient.addFields({ usePreGeneratedPkce: !!res }, correlationId);
         return res;
     }
-    logMultipleInstances(performanceEvent) {
+    logMultipleInstances(performanceEvent, correlationId) {
         const clientId = this.config.auth.clientId;
         if (!window)
             return;
@@ -1443,11 +1343,11 @@ class StandardController {
         // @ts-ignore
         const clientIds = window.msal.clientIds;
         if (clientIds.length > 0) {
-            this.logger.verbose("There is already an instance of MSAL.js in the window.");
+            this.logger.verbose("There is already an instance of MSAL.js in the window.", correlationId);
         }
         // @ts-ignore
         window.msal.clientIds.push(clientId);
-        collectInstanceStats(clientId, performanceEvent, this.logger);
+        collectInstanceStats(clientId, performanceEvent, this.logger, correlationId);
     }
 }
 /**