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

package/src/controllers/StandardController.ts

@@ -7,30 +7,29 @@ import { CryptoOps } from "../crypto/CryptoOps.js";
 import {
     InteractionRequiredAuthError,
     AccountInfo,
-    Constants,
     INetworkModule,
     Logger,
     CommonSilentFlowRequest,
     ICrypto,
     DEFAULT_CRYPTO_IMPLEMENTATION,
     AuthError,
-    PerformanceEvents,
     PerformanceCallbackFunction,
     IPerformanceClient,
     BaseAuthRequest,
-    PromptValue,
     InProgressPerformanceEvent,
     getRequestThumbprint,
-    AccountEntity,
     invokeAsync,
-    invoke,
     createClientAuthError,
     ClientAuthErrorCodes,
     AccountFilter,
     buildStaticAuthorityOptions,
     InteractionRequiredAuthErrorCodes,
     PkceCodes,
+    AccountEntityUtils,
+    Constants,
 } from "@azure/msal-common/browser";
+import * as BrowserPerformanceEvents from "../telemetry/BrowserPerformanceEvents.js";
+import * as BrowserRootPerformanceEvents from "../telemetry/BrowserRootPerformanceEvents.js";
 import {
     BrowserCacheManager,
     DEFAULT_BROWSER_CACHE_MANAGER,
@@ -62,8 +61,6 @@ import { PopupClient } from "../interaction_client/PopupClient.js";
 import { RedirectClient } from "../interaction_client/RedirectClient.js";
 import { SilentIframeClient } from "../interaction_client/SilentIframeClient.js";
 import { SilentRefreshClient } from "../interaction_client/SilentRefreshClient.js";
-import { TokenCache } from "../cache/TokenCache.js";
-import { ITokenCache } from "../cache/ITokenCache.js";
 import { PlatformAuthInteractionClient } from "../interaction_client/PlatformAuthInteractionClient.js";
 import { SilentRequest } from "../request/SilentRequest.js";
 import {
@@ -80,7 +77,7 @@ import { AuthorizationCodeRequest } from "../request/AuthorizationCodeRequest.js
 import { PlatformAuthRequest } from "../broker/nativeBroker/PlatformAuthRequest.js";
 import { StandardOperatingContext } from "../operatingcontext/StandardOperatingContext.js";
 import { BaseOperatingContext } from "../operatingcontext/BaseOperatingContext.js";
-import { IController } from "./IController.js";
+import { HandleRedirectPromiseOptions, IController } from "./IController.js";
 import { AuthenticationResult } from "../response/AuthenticationResult.js";
 import { ClearCacheRequest } from "../request/ClearCacheRequest.js";
 import { createNewGuid } from "../crypto/BrowserCrypto.js";
@@ -94,15 +91,30 @@ import {
 import { IPlatformAuthHandler } from "../broker/nativeBroker/IPlatformAuthHandler.js";
 import { collectInstanceStats } from "../utils/MsalFrameStatsUtils.js";
 
+function getAccountType(
+    account?: AccountInfo
+): "AAD" | "MSA" | "B2C" | undefined {
+    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: boolean,
-    performanceEvent: InProgressPerformanceEvent,
-    account?: AccountInfo
+    performanceEvent: InProgressPerformanceEvent
 ) {
     try {
         BrowserUtils.preflightCheck(initialized);
     } catch (e) {
-        performanceEvent.end({ success: false }, e, account);
+        performanceEvent.end({ success: false }, e);
         throw e;
     }
 }
@@ -129,9 +141,6 @@ export class StandardController implements IController {
     // Input configuration by developer/user
     protected readonly config: BrowserConfiguration;
 
-    // Token cache implementation
-    private tokenCache: TokenCache;
-
     // Logger
     protected logger: Logger;
 
@@ -248,11 +257,6 @@ export class StandardController implements IController {
         const nativeCacheOptions: Required<CacheOptions> = {
             cacheLocation: BrowserCacheLocation.MemoryStorage,
             cacheRetentionDays: 5,
-            temporaryCacheLocation: BrowserCacheLocation.MemoryStorage,
-            storeAuthStateInCookie: false,
-            secureCookies: false,
-            cacheMigrationEnabled: false,
-            claimsBasedCachingEnabled: false,
         };
         this.nativeInternalStorage = new BrowserCacheManager(
             this.config.auth.clientId,
@@ -263,14 +267,6 @@ export class StandardController implements IController {
             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
@@ -294,7 +290,7 @@ export class StandardController implements IController {
         if (!correlationId) {
             return;
         }
-        this.logger.info("Perf: Visibility change detected");
+        this.logger.info("Perf: Visibility change detected", correlationId);
         this.performanceClient.incrementFields(
             { visibilityChangeCount: 1 },
             correlationId
@@ -309,16 +305,21 @@ export class StandardController implements IController {
         request?: InitializeApplicationRequest,
         isBroker?: boolean
     ): Promise<void> {
-        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."
+                "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;
@@ -328,7 +329,7 @@ export class StandardController implements IController {
             request?.correlationId || this.getRequestCorrelationId();
         const allowPlatformBroker = this.config.system.allowPlatformBroker;
         const initMeasurement = this.performanceClient.startMeasurement(
-            PerformanceEvents.InitializeClientApplication,
+            BrowserRootPerformanceEvents.InitializeClientApplication,
             initCorrelationId
         );
         this.eventHandler.emitEvent(EventType.INITIALIZE_START);
@@ -336,13 +337,13 @@ export class StandardController implements IController {
         // 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,
+            BrowserPerformanceEvents.InitializeCache,
             this.logger,
             this.performanceClient,
             initCorrelationId
@@ -358,27 +359,18 @@ export class StandardController implements IController {
                     this.config.system.nativeBrokerHandshakeTimeout
                 );
             } catch (e) {
-                this.logger.verbose(e as string);
+                this.logger.verbose(e as string, 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);
@@ -395,39 +387,42 @@ export class StandardController implements IController {
      * 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?: string
+        options?: HandleRedirectPromiseOptions
     ): Promise<AuthenticationResult | null> {
-        this.logger.verbose("handleRedirectPromise called");
+        this.logger.verbose("handleRedirectPromise called", "");
         // Block token acquisition before initialize has been called
         BrowserUtils.blockAPICallsBeforeInitialize(this.initialized);
-
         if (this.isBrowserEnvironment) {
             /**
              * Store the promise on the PublicClientApplication instance if this is the first invocation of handleRedirectPromise,
              * 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"
+                    "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"
+                    "handleRedirectPromise has been called previously, returning the result from the first call",
+                    ""
                 );
             }
 
             return response;
         }
         this.logger.verbose(
-            "handleRedirectPromise returns null, not browser environment"
+            "handleRedirectPromise returns null, not browser environment",
+            ""
         );
         return null;
     }
@@ -438,11 +433,12 @@ export class StandardController implements IController {
      * @returns
      */
     private async handleRedirectPromiseInternal(
-        hash?: string
+        options?: HandleRedirectPromiseOptions
     ): Promise<AuthenticationResult | null> {
         if (!this.browserStorage.isInteractionInProgress(true)) {
             this.logger.info(
-                "handleRedirectPromise called but there is no interaction in progress, returning null."
+                "handleRedirectPromise called but there is no interaction in progress, returning null.",
+                ""
             );
             return null;
         }
@@ -451,7 +447,8 @@ export class StandardController implements IController {
             this.browserStorage.getInteractionInProgress()?.type;
         if (interactionType === INTERACTION_TYPE.SIGNOUT) {
             this.logger.verbose(
-                "handleRedirectPromise removing interaction_in_progress flag and returning null after sign-out"
+                "handleRedirectPromise removing interaction_in_progress flag and returning null after sign-out",
+                ""
             );
             this.browserStorage.setInteractionInProgress(false);
             return Promise.resolve(null);
@@ -461,7 +458,9 @@ export class StandardController implements IController {
         const platformBrokerRequest: PlatformAuthRequest | null =
             this.browserStorage.getCachedNativeRequest();
         const useNative =
-            platformBrokerRequest && this.platformAuthProvider && !hash;
+            platformBrokerRequest &&
+            this.platformAuthProvider &&
+            !options?.hash;
 
         let rootMeasurement: InProgressPerformanceEvent;
 
@@ -473,16 +472,16 @@ export class StandardController implements IController {
         let redirectResponse: Promise<AuthenticationResult | null>;
         try {
             if (useNative && this.platformAuthProvider) {
+                const correlationId =
+                    platformBrokerRequest?.correlationId || "";
                 rootMeasurement = this.performanceClient.startMeasurement(
-                    PerformanceEvents.AcquireTokenRedirect,
-                    platformBrokerRequest?.correlationId || ""
+                    BrowserRootPerformanceEvents.AcquireTokenRedirect,
+                    correlationId
                 );
                 this.logger.trace(
-                    "handleRedirectPromise - acquiring token from native platform"
+                    "handleRedirectPromise - acquiring token from native platform",
+                    correlationId
                 );
-                rootMeasurement.add({
-                    isPlatformBrokerRequest: true,
-                });
                 const nativeClient = new PlatformAuthInteractionClient(
                     this.config,
                     this.browserStorage,
@@ -500,41 +499,51 @@ export class StandardController implements IController {
 
                 redirectResponse = invokeAsync(
                     nativeClient.handleRedirectPromise.bind(nativeClient),
-                    PerformanceEvents.HandleNativeRedirectPromiseMeasurement,
+                    BrowserPerformanceEvents.HandleNativeRedirectPromiseMeasurement,
                     this.logger,
                     this.performanceClient,
                     rootMeasurement.event.correlationId
                 )(this.performanceClient, rootMeasurement.event.correlationId);
             } else {
                 const [standardRequest, codeVerifier] =
-                    this.browserStorage.getCachedRequest();
+                    this.browserStorage.getCachedRequest("");
                 const correlationId = standardRequest.correlationId;
                 // Reset rootMeasurement now that we have correlationId
                 rootMeasurement = this.performanceClient.startMeasurement(
-                    PerformanceEvents.AcquireTokenRedirect,
+                    BrowserRootPerformanceEvents.AcquireTokenRedirect,
                     correlationId
                 );
                 this.logger.trace(
-                    "handleRedirectPromise - acquiring token from web flow"
+                    "handleRedirectPromise - acquiring token from web flow",
+                    correlationId
                 );
                 const redirectClient = this.createRedirectClient(correlationId);
                 redirectResponse = invokeAsync(
                     redirectClient.handleRedirectPromise.bind(redirectClient),
-                    PerformanceEvents.HandleRedirectPromiseMeasurement,
+                    BrowserPerformanceEvents.HandleRedirectPromiseMeasurement,
                     this.logger,
                     this.performanceClient,
                     rootMeasurement.event.correlationId
-                )(hash, standardRequest, codeVerifier, rootMeasurement);
+                )(standardRequest, codeVerifier, rootMeasurement, options);
             }
         } catch (e) {
-            this.browserStorage.resetRequestCache();
+            this.browserStorage.resetRequestCache("");
             throw e;
         }
 
         return redirectResponse
             .then((result: AuthenticationResult | null) => {
                 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;
@@ -542,35 +551,24 @@ export class StandardController implements IController {
                         this.eventHandler.emitEvent(
                             EventType.LOGIN_SUCCESS,
                             InteractionType.Redirect,
-                            result
+                            result.account
                         );
                         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"
+                            "handleRedirectResponse returned result, login success",
+                            result.correlationId
                         );
                     }
-                    rootMeasurement.end(
-                        {
-                            success: true,
-                        },
-                        undefined,
-                        result.account
-                    );
+                    rootMeasurement.end({
+                        success: true,
+                        accountType: getAccountType(result.account),
+                    });
                 } else {
                     /*
                      * Instrument an event only if an error code is set. Otherwise, discard it when the redirect response
                      * is empty and the error code is missing.
                      */
                     if (rootMeasurement.event.errorCode) {
-                        rootMeasurement.end({ success: false }, undefined);
+                        rootMeasurement.end({ success: false });
                     } else {
                         rootMeasurement.discard();
                     }
@@ -584,24 +582,16 @@ export class StandardController implements IController {
                 return result;
             })
             .catch((e) => {
-                this.browserStorage.resetRequestCache();
+                this.browserStorage.resetRequestCache(
+                    rootMeasurement.event.correlationId
+                );
                 const eventError = e as EventError;
-                // 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
@@ -633,55 +623,28 @@ export class StandardController implements IController {
         this.logger.verbose("acquireTokenRedirect called", correlationId);
 
         const atrMeasurement = this.performanceClient.startMeasurement(
-            PerformanceEvents.AcquireTokenPreRedirect,
+            BrowserRootPerformanceEvents.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: string) => {
-                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: string) => {
-                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;
-            };
-        }
+        const configOnRedirectNavigateCb = this.config.auth.onRedirectNavigate;
+        this.config.auth.onRedirectNavigate = (url: string) => {
+            const navigate =
+                typeof configOnRedirectNavigateCb === "function"
+                    ? configOnRedirectNavigateCb(url)
+                    : undefined;
+            atrMeasurement.add({
+                navigateCallbackResult: navigate !== false,
+            });
+            atrMeasurement.event =
+                atrMeasurement.end({ success: true }) || atrMeasurement.event;
+            return navigate;
+        };
 
-        // If logged in, emit acquire token events
-        const isLoggedIn = this.getAllAccounts().length > 0;
         try {
             BrowserUtils.redirectPreflightCheck(this.initialized, this.config);
             this.browserStorage.setInteractionInProgress(
@@ -689,19 +652,11 @@ export class StandardController implements IController {
                 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: Promise<void>;
 
@@ -723,25 +678,21 @@ export class StandardController implements IController {
                     this.nativeInternalStorage,
                     correlationId
                 );
-
                 result = nativeClient
                     .acquireTokenRedirect(request, atrMeasurement)
                     .catch((e: AuthError) => {
-                        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"
+                                "acquireTokenRedirect - Resolving interaction required error thrown by native broker by falling back to web flow",
+                                correlationId
                             );
                             const redirectClient =
                                 this.createRedirectClient(correlationId);
@@ -756,7 +707,7 @@ export class StandardController implements IController {
 
             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.
@@ -764,29 +715,20 @@ export class StandardController implements IController {
             if (atrMeasurement.event.status === 2) {
                 this.performanceClient
                     .startMeasurement(
-                        PerformanceEvents.AcquireTokenRedirect,
+                        BrowserRootPerformanceEvents.AcquireTokenRedirect,
                         correlationId
                     )
-                    .end({ success: false }, e, request.account);
+                    .end({ success: false }, e);
             } else {
-                atrMeasurement.end({ success: false }, e, request.account);
+                atrMeasurement.end({ success: false }, e);
             }
 
-            if (isLoggedIn) {
-                this.eventHandler.emitEvent(
-                    EventType.ACQUIRE_TOKEN_FAILURE,
-                    InteractionType.Redirect,
-                    null,
-                    e as EventError
-                );
-            } else {
-                this.eventHandler.emitEvent(
-                    EventType.LOGIN_FAILURE,
-                    InteractionType.Redirect,
-                    null,
-                    e as EventError
-                );
-            }
+            this.eventHandler.emitEvent(
+                EventType.ACQUIRE_TOKEN_FAILURE,
+                InteractionType.Redirect,
+                null,
+                e as EventError
+            );
             throw e;
         }
     }
@@ -805,21 +747,18 @@ export class StandardController implements IController {
     acquireTokenPopup(request: PopupRequest): Promise<AuthenticationResult> {
         const correlationId = this.getRequestCorrelationId(request);
         const atPopupMeasurement = this.performanceClient.startMeasurement(
-            PerformanceEvents.AcquireTokenPopup,
+            BrowserRootPerformanceEvents.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
@@ -831,27 +770,16 @@ export class StandardController implements IController {
 
         // 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: Promise<AuthenticationResult>;
         const pkce = this.getPreGeneratedPkceCodes(correlationId);
 
         if (this.canUsePlatformBroker(request)) {
-            atPopupMeasurement.add({
-                isPlatformBrokerRequest: true,
-            });
             result = this.acquireTokenNative(
                 {
                     ...request,
@@ -860,31 +788,26 @@ export class StandardController implements IController {
                 ApiId.acquireTokenPopup
             )
                 .then((response) => {
-                    atPopupMeasurement.end(
-                        {
-                            success: true,
-                        },
-                        undefined,
-                        response.account
-                    );
+                    atPopupMeasurement.end({
+                        success: true,
+                        isNativeBroker: true,
+                        accountType: getAccountType(response.account),
+                    });
                     return response;
                 })
                 .catch((e: AuthError) => {
-                    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"
+                            "acquireTokenPopup - Resolving interaction required error thrown by native broker by falling back to web flow",
+                            correlationId
                         );
                         const popupClient =
                             this.createPopupClient(correlationId);
@@ -904,54 +827,39 @@ export class StandardController implements IController {
                  */
                 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
+                        result.account
                     );
                 }
 
-                atPopupMeasurement.end(
-                    {
-                        success: true,
-                        accessTokenSize: result.accessToken.length,
-                        idTokenSize: result.idToken.length,
-                    },
-                    undefined,
-                    result.account
-                );
+                atPopupMeasurement.end({
+                    success: true,
+                    accessTokenSize: result.accessToken.length,
+                    idTokenSize: result.idToken.length,
+                    accountType: getAccountType(result.account),
+                });
                 return result;
             })
             .catch((e: Error) => {
-                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
@@ -959,7 +867,7 @@ export class StandardController implements IController {
             })
             .finally(async () => {
                 this.browserStorage.setInteractionInProgress(false);
-                if (this.config.system.asyncPopups) {
+                if (!this.config.system.navigatePopups) {
                     await this.preGeneratePkceCodes(correlationId);
                 }
             });
@@ -973,10 +881,6 @@ export class StandardController implements IController {
             return;
         }
 
-        this.logger.info(
-            "Perf: Visibility change detected in ",
-            measurement.event.name
-        );
         measurement.increment({
             visibilityChangeCount: 1,
         });
@@ -1009,17 +913,14 @@ export class StandardController implements IController {
             correlationId: correlationId,
         };
         this.ssoSilentMeasurement = this.performanceClient.startMeasurement(
-            PerformanceEvents.SsoSilent,
+            BrowserRootPerformanceEvents.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,
         });
@@ -1028,9 +929,11 @@ export class StandardController implements IController {
             "visibilitychange",
             this.trackPageVisibilityWithMeasurement
         );
+
+        const loggedInAccounts = this.getAllAccounts();
         this.logger.verbose("ssoSilent called", correlationId);
         this.eventHandler.emitEvent(
-            EventType.SSO_SILENT_START,
+            EventType.ACQUIRE_TOKEN_START,
             InteractionType.Silent,
             validRequest
         );
@@ -1038,17 +941,10 @@ export class StandardController implements IController {
         let result: Promise<AuthenticationResult>;
 
         if (this.canUsePlatformBroker(validRequest)) {
-            this.ssoSilentMeasurement?.add({
-                isPlatformBrokerRequest: true,
-            });
             result = this.acquireTokenNative(
                 validRequest,
                 ApiId.ssoSilent
             ).catch((e: AuthError) => {
-                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
@@ -1068,25 +964,32 @@ export class StandardController implements IController {
 
         return result
             .then((response) => {
+                const isLoggingIn =
+                    loggedInAccounts.length < this.getAllAccounts().length;
                 this.eventHandler.emitEvent(
-                    EventType.SSO_SILENT_SUCCESS,
+                    EventType.ACQUIRE_TOKEN_SUCCESS,
                     InteractionType.Silent,
                     response
                 );
-                this.ssoSilentMeasurement?.end(
-                    {
-                        success: true,
-                        accessTokenSize: response.accessToken.length,
-                        idTokenSize: response.idToken.length,
-                    },
-                    undefined,
-                    response.account
-                );
+                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,
+                    accountType: getAccountType(response.account),
+                });
                 return response;
             })
             .catch((e: Error) => {
                 this.eventHandler.emitEvent(
-                    EventType.SSO_SILENT_FAILURE,
+                    EventType.ACQUIRE_TOKEN_FAILURE,
                     InteractionType.Silent,
                     null,
                     e
@@ -1095,8 +998,7 @@ export class StandardController implements IController {
                     {
                         success: false,
                     },
-                    e,
-                    request.account
+                    e
                 );
                 throw e;
             })
@@ -1124,12 +1026,12 @@ export class StandardController implements IController {
         const correlationId = this.getRequestCorrelationId(request);
         this.logger.trace("acquireTokenByCode called", correlationId);
         const atbcMeasurement = this.performanceClient.startMeasurement(
-            PerformanceEvents.AcquireTokenByCode,
+            BrowserRootPerformanceEvents.AcquireTokenByCode,
             correlationId
         );
         preflightCheck(this.initialized, atbcMeasurement);
         this.eventHandler.emitEvent(
-            EventType.ACQUIRE_TOKEN_BY_CODE_START,
+            EventType.ACQUIRE_TOKEN_START,
             InteractionType.Silent,
             request
         );
@@ -1155,26 +1057,24 @@ export class StandardController implements IController {
                     })
                         .then((result: AuthenticationResult) => {
                             this.eventHandler.emitEvent(
-                                EventType.ACQUIRE_TOKEN_BY_CODE_SUCCESS,
+                                EventType.ACQUIRE_TOKEN_SUCCESS,
                                 InteractionType.Silent,
                                 result
                             );
                             this.hybridAuthCodeResponses.delete(hybridAuthCode);
-                            atbcMeasurement.end(
-                                {
-                                    success: true,
-                                    accessTokenSize: result.accessToken.length,
-                                    idTokenSize: result.idToken.length,
-                                },
-                                undefined,
-                                result.account
-                            );
+                            atbcMeasurement.end({
+                                success: true,
+                                isNativeBroker: result.fromPlatformBroker,
+                                accessTokenSize: result.accessToken.length,
+                                idTokenSize: result.idToken.length,
+                                accountType: getAccountType(result.account),
+                            });
                             return result;
                         })
                         .catch((error: Error) => {
                             this.hybridAuthCodeResponses.delete(hybridAuthCode);
                             this.eventHandler.emitEvent(
-                                EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE,
+                                EventType.ACQUIRE_TOKEN_FAILURE,
                                 InteractionType.Silent,
                                 null,
                                 error
@@ -1200,9 +1100,6 @@ export class StandardController implements IController {
                 if (
                     this.canUsePlatformBroker(request, request.nativeAccountId)
                 ) {
-                    atbcMeasurement.add({
-                        isPlatformBrokerRequest: true,
-                    });
                     const result = await this.acquireTokenNative(
                         {
                             ...request,
@@ -1218,19 +1115,12 @@ export class StandardController implements IController {
                         ) {
                             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(
-                        {
-                            success: true,
-                        },
-                        undefined,
-                        result.account
-                    );
+                    atbcMeasurement.end({
+                        accountType: getAccountType(result.account),
+                        success: true,
+                    });
                     return result;
                 } else {
                     throw createBrowserAuthError(
@@ -1244,7 +1134,7 @@ export class StandardController implements IController {
             }
         } catch (e) {
             this.eventHandler.emitEvent(
-                EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE,
+                EventType.ACQUIRE_TOKEN_FAILURE,
                 InteractionType.Silent,
                 null,
                 e as EventError
@@ -1267,14 +1157,12 @@ export class StandardController implements IController {
     private async acquireTokenByCodeAsync(
         request: AuthorizationCodeRequest
     ): Promise<AuthenticationResult> {
-        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
+                BrowserPerformanceEvents.AcquireTokenByCodeAsync,
+                correlationId
             );
         this.acquireTokenByCodeAsyncMeasurement?.increment({
             visibilityChangeCount: 0,
@@ -1283,15 +1171,15 @@ export class StandardController implements IController {
             "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;
             })
@@ -1324,10 +1212,6 @@ export class StandardController implements IController {
         commonRequest: CommonSilentFlowRequest,
         cacheLookupPolicy: CacheLookupPolicy
     ): Promise<AuthenticationResult> {
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.AcquireTokenFromCache,
-            commonRequest.correlationId
-        );
         switch (cacheLookupPolicy) {
             case CacheLookupPolicy.Default:
             case CacheLookupPolicy.AccessToken:
@@ -1337,7 +1221,7 @@ export class StandardController implements IController {
                 );
                 return invokeAsync(
                     silentCacheClient.acquireToken.bind(silentCacheClient),
-                    PerformanceEvents.SilentCacheClientAcquireToken,
+                    BrowserPerformanceEvents.SilentCacheClientAcquireToken,
                     this.logger,
                     this.performanceClient,
                     commonRequest.correlationId
@@ -1359,10 +1243,6 @@ export class StandardController implements IController {
         commonRequest: CommonSilentFlowRequest,
         cacheLookupPolicy: CacheLookupPolicy
     ): Promise<AuthenticationResult> {
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.AcquireTokenByRefreshToken,
-            commonRequest.correlationId
-        );
         switch (cacheLookupPolicy) {
             case CacheLookupPolicy.Default:
             case CacheLookupPolicy.AccessTokenAndRefreshToken:
@@ -1374,7 +1254,7 @@ export class StandardController implements IController {
 
                 return invokeAsync(
                     silentRefreshClient.acquireToken.bind(silentRefreshClient),
-                    PerformanceEvents.SilentRefreshClientAcquireToken,
+                    BrowserPerformanceEvents.SilentRefreshClientAcquireToken,
                     this.logger,
                     this.performanceClient,
                     commonRequest.correlationId
@@ -1394,18 +1274,13 @@ export class StandardController implements IController {
     protected async acquireTokenBySilentIframe(
         request: CommonSilentFlowRequest
     ): Promise<AuthenticationResult> {
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.AcquireTokenBySilentIframe,
-            request.correlationId
-        );
-
         const silentIframeClient = this.createSilentIframeClient(
             request.correlationId
         );
 
         return invokeAsync(
             silentIframeClient.acquireToken.bind(silentIframeClient),
-            PerformanceEvents.SilentIframeClientAcquireToken,
+            BrowserPerformanceEvents.SilentIframeClientAcquireToken,
             this.logger,
             this.performanceClient,
             request.correlationId
@@ -1416,23 +1291,6 @@ export class StandardController implements IController {
 
     // #region Logout
 
-    /**
-     * Deprecated logout function. Use logoutRedirect or logoutPopup instead
-     * @param logoutRequest
-     * @deprecated
-     */
-    async logout(logoutRequest?: EndSessionRequest): Promise<void> {
-        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`.
@@ -1479,7 +1337,6 @@ export class StandardController implements IController {
      */
     async clearCache(logoutRequest?: ClearCacheRequest): Promise<void> {
         if (!this.isBrowserEnvironment) {
-            this.logger.info("in non-browser environment, returning early.");
             return;
         }
         const correlationId = this.getRequestCorrelationId(logoutRequest);
@@ -1497,12 +1354,11 @@ export class StandardController implements IController {
      * @returns Array of AccountInfo objects in cache
      */
     getAllAccounts(accountFilter?: AccountFilter): AccountInfo[] {
-        const correlationId = this.getRequestCorrelationId();
         return AccountManager.getAllAccounts(
             this.logger,
             this.browserStorage,
             this.isBrowserEnvironment,
-            correlationId,
+            this.getRequestCorrelationId(),
             accountFilter
         );
     }
@@ -1513,12 +1369,11 @@ export class StandardController implements IController {
      * @returns The first account found in the cache matching the provided filter or null if no account could be found.
      */
     getAccount(accountFilter: AccountFilter): AccountInfo | null {
-        const correlationId = this.getRequestCorrelationId();
         return AccountManager.getAccount(
             accountFilter,
             this.logger,
             this.browserStorage,
-            correlationId
+            this.getRequestCorrelationId()
         );
     }
 
@@ -1531,12 +1386,11 @@ export class StandardController implements IController {
      * @returns The account object stored in MSAL
      */
     getAccountByUsername(username: string): AccountInfo | null {
-        const correlationId = this.getRequestCorrelationId();
         return AccountManager.getAccountByUsername(
             username,
             this.logger,
             this.browserStorage,
-            correlationId
+            this.getRequestCorrelationId()
         );
     }
 
@@ -1548,12 +1402,11 @@ export class StandardController implements IController {
      * @returns The account object stored in MSAL
      */
     getAccountByHomeId(homeAccountId: string): AccountInfo | null {
-        const correlationId = this.getRequestCorrelationId();
         return AccountManager.getAccountByHomeId(
             homeAccountId,
             this.logger,
             this.browserStorage,
-            correlationId
+            this.getRequestCorrelationId()
         );
     }
 
@@ -1565,12 +1418,11 @@ export class StandardController implements IController {
      * @returns The account object stored in MSAL
      */
     getAccountByLocalId(localAccountId: string): AccountInfo | null {
-        const correlationId = this.getRequestCorrelationId();
         return AccountManager.getAccountByLocalId(
             localAccountId,
             this.logger,
             this.browserStorage,
-            correlationId
+            this.getRequestCorrelationId()
         );
     }
 
@@ -1579,11 +1431,10 @@ export class StandardController implements IController {
      * @param account
      */
     setActiveAccount(account: AccountInfo | null): void {
-        const correlationId = this.getRequestCorrelationId();
         AccountManager.setActiveAccount(
             account,
             this.browserStorage,
-            correlationId
+            this.getRequestCorrelationId()
         );
     }
 
@@ -1591,10 +1442,9 @@ export class StandardController implements IController {
      * Gets the currently active account
      */
     getActiveAccount(): AccountInfo | null {
-        const correlationId = this.getRequestCorrelationId();
         return AccountManager.getActiveAccount(
             this.browserStorage,
-            correlationId
+            this.getRequestCorrelationId()
         );
     }
 
@@ -1614,22 +1464,24 @@ export class StandardController implements IController {
             | RedirectRequest
             | PopupRequest
     ): Promise<void> {
-        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) {
+        if (result.fromPlatformBroker) {
             this.logger.verbose(
-                "Response was from native broker, storing in-memory"
+                "Response was from native broker, storing in-memory",
+                result.correlationId
             );
             // Tokens from native broker are stored in-memory
             return this.nativeInternalStorage.hydrateCache(result, request);
@@ -1650,12 +1502,14 @@ export class StandardController implements IController {
         accountId?: string,
         cacheLookupPolicy?: CacheLookupPolicy
     ): Promise<AuthenticationResult> {
-        this.logger.trace("acquireTokenNative called");
+        const correlationId = this.getRequestCorrelationId(request);
+        this.logger.trace("acquireTokenNative called", correlationId);
         if (!this.platformAuthProvider) {
             throw createBrowserAuthError(
                 BrowserAuthErrorCodes.nativeConnectionNotEstablished
             );
         }
+
         const nativeClient = new PlatformAuthInteractionClient(
             this.config,
             this.browserStorage,
@@ -1668,7 +1522,7 @@ export class StandardController implements IController {
             this.platformAuthProvider,
             accountId || this.getNativeAccountId(request),
             this.nativeInternalStorage,
-            request.correlationId
+            correlationId
         );
 
         return nativeClient.acquireToken(request, cacheLookupPolicy);
@@ -1682,10 +1536,12 @@ export class StandardController implements IController {
         request: RedirectRequest | PopupRequest | SsoSilentRequest,
         accountId?: string
     ): boolean {
-        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"
+                "canUsePlatformBroker: platform broker unavilable, returning false",
+                correlationId
             );
             return false;
         }
@@ -1694,29 +1550,32 @@ export class StandardController implements IController {
             !isPlatformAuthAllowed(
                 this.config,
                 this.logger,
+                correlationId,
                 this.platformAuthProvider,
                 request.authenticationScheme
             )
         ) {
             this.logger.trace(
-                "canUsePlatformBroker: isBrokerAvailable returned false, returning false"
+                "canUsePlatformBroker: isBrokerAvailable returned false, returning false",
+                correlationId
             );
             return false;
         }
 
         if (request.prompt) {
             switch (request.prompt) {
-                case PromptValue.NONE:
-                case PromptValue.CONSENT:
-                case PromptValue.LOGIN:
-                case PromptValue.SELECT_ACCOUNT:
+                case Constants.PromptValue.NONE:
+                case Constants.PromptValue.CONSENT:
+                case Constants.PromptValue.LOGIN:
                     this.logger.trace(
-                        "canUsePlatformBroker: prompt is compatible with platform broker flow"
+                        "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`
+                        `canUsePlatformBroker: prompt = '${request.prompt}' is not compatible with platform broker flow, returning false`,
+                        correlationId
                     );
                     return false;
             }
@@ -1724,7 +1583,8 @@ export class StandardController implements IController {
 
         if (!accountId && !this.getNativeAccountId(request)) {
             this.logger.trace(
-                "canUsePlatformBroker: nativeAccountId is not available, returning false"
+                "canUsePlatformBroker: nativeAccountId is not available, returning false",
+                correlationId
             );
             return false;
         }
@@ -1755,7 +1615,7 @@ export class StandardController implements IController {
      * Returns new instance of the Popup Interaction Client
      * @param correlationId
      */
-    public createPopupClient(correlationId?: string): PopupClient {
+    public createPopupClient(correlationId: string): PopupClient {
         return new PopupClient(
             this.config,
             this.browserStorage,
@@ -1765,8 +1625,8 @@ export class StandardController implements IController {
             this.navigationClient,
             this.performanceClient,
             this.nativeInternalStorage,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1774,7 +1634,7 @@ export class StandardController implements IController {
      * Returns new instance of the Redirect Interaction Client
      * @param correlationId
      */
-    protected createRedirectClient(correlationId?: string): RedirectClient {
+    protected createRedirectClient(correlationId: string): RedirectClient {
         return new RedirectClient(
             this.config,
             this.browserStorage,
@@ -1784,8 +1644,8 @@ export class StandardController implements IController {
             this.navigationClient,
             this.performanceClient,
             this.nativeInternalStorage,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1793,9 +1653,7 @@ export class StandardController implements IController {
      * Returns new instance of the Silent Iframe Interaction Client
      * @param correlationId
      */
-    public createSilentIframeClient(
-        correlationId?: string
-    ): SilentIframeClient {
+    public createSilentIframeClient(correlationId: string): SilentIframeClient {
         return new SilentIframeClient(
             this.config,
             this.browserStorage,
@@ -1806,8 +1664,8 @@ export class StandardController implements IController {
             ApiId.ssoSilent,
             this.performanceClient,
             this.nativeInternalStorage,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1815,7 +1673,7 @@ export class StandardController implements IController {
      * Returns new instance of the Silent Cache Interaction Client
      */
     protected createSilentCacheClient(
-        correlationId?: string
+        correlationId: string
     ): SilentCacheClient {
         return new SilentCacheClient(
             this.config,
@@ -1825,8 +1683,8 @@ export class StandardController implements IController {
             this.eventHandler,
             this.navigationClient,
             this.performanceClient,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1834,7 +1692,7 @@ export class StandardController implements IController {
      * Returns new instance of the Silent Refresh Interaction Client
      */
     protected createSilentRefreshClient(
-        correlationId?: string
+        correlationId: string
     ): SilentRefreshClient {
         return new SilentRefreshClient(
             this.config,
@@ -1844,8 +1702,8 @@ export class StandardController implements IController {
             this.eventHandler,
             this.navigationClient,
             this.performanceClient,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1853,7 +1711,7 @@ export class StandardController implements IController {
      * Returns new instance of the Silent AuthCode Interaction Client
      */
     protected createSilentAuthCodeClient(
-        correlationId?: string
+        correlationId: string
     ): SilentAuthCodeClient {
         return new SilentAuthCodeClient(
             this.config,
@@ -1864,8 +1722,8 @@ export class StandardController implements IController {
             this.navigationClient,
             ApiId.acquireTokenByCode,
             this.performanceClient,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1909,49 +1767,6 @@ export class StandardController implements IController {
         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(): void {
-        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(): void {
-        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(): ITokenCache {
-        return this.tokenCache;
-    }
-
     /**
      * Returns the logger instance
      */
@@ -2028,7 +1843,7 @@ export class StandardController implements IController {
          * Included for fallback for non-browser environments,
          * and to ensure this method always returns a string.
          */
-        return Constants.EMPTY_STRING;
+        return "";
     }
 
     // #endregion
@@ -2078,7 +1893,7 @@ export class StandardController implements IController {
     ): Promise<AuthenticationResult> {
         const correlationId = this.getRequestCorrelationId(request);
         const atsMeasurement = this.performanceClient.startMeasurement(
-            PerformanceEvents.AcquireTokenSilent,
+            BrowserRootPerformanceEvents.AcquireTokenSilent,
             correlationId
         );
         atsMeasurement.add({
@@ -2086,26 +1901,24 @@ export class StandardController implements IController {
             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(BrowserAuthErrorCodes.noAccountError);
         }
+        atsMeasurement.add({ accountType: getAccountType(account) });
 
         return this.acquireTokenSilentDeduped(request, account, correlationId)
             .then((result) => {
-                atsMeasurement.end(
-                    {
-                        success: true,
-                        fromCache: result.fromCache,
-                        accessTokenSize: result.accessToken.length,
-                        idTokenSize: result.idToken.length,
-                    },
-                    undefined,
-                    result.account
-                );
+                atsMeasurement.end({
+                    success: true,
+                    fromCache: result.fromCache,
+                    isNativeBroker: result.fromPlatformBroker,
+                    accessTokenSize: result.accessToken.length,
+                    idTokenSize: result.idToken.length,
+                });
                 return {
                     ...result,
                     state: request.state,
@@ -2122,8 +1935,7 @@ export class StandardController implements IController {
                     {
                         success: false,
                     },
-                    error,
-                    account
+                    error
                 );
                 throw error;
             });
@@ -2164,7 +1976,7 @@ export class StandardController implements IController {
 
             const activeRequest = invokeAsync(
                 this.acquireTokenSilentAsync.bind(this),
-                PerformanceEvents.AcquireTokenSilentAsync,
+                BrowserPerformanceEvents.AcquireTokenSilentAsync,
                 this.logger,
                 this.performanceClient,
                 correlationId
@@ -2202,11 +2014,6 @@ export class StandardController implements IController {
     ): Promise<AuthenticationResult> {
         const trackPageVisibility = () =>
             this.trackPageVisibility(request.correlationId);
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.AcquireTokenSilentAsync,
-            request.correlationId
-        );
-
         this.eventHandler.emitEvent(
             EventType.ACQUIRE_TOKEN_START,
             InteractionType.Silent,
@@ -2224,7 +2031,7 @@ export class StandardController implements IController {
 
         const silentRequest = await invokeAsync(
             initializeSilentRequest,
-            PerformanceEvents.InitializeSilentRequest,
+            BrowserPerformanceEvents.InitializeSilentRequest,
             this.logger,
             this.performanceClient,
             request.correlationId
@@ -2258,7 +2065,7 @@ export class StandardController implements IController {
                     );
                     return invokeAsync(
                         this.acquireTokenBySilentIframe.bind(this),
-                        PerformanceEvents.AcquireTokenBySilentIframe,
+                        BrowserPerformanceEvents.AcquireTokenBySilentIframe,
                         this.logger,
                         this.performanceClient,
                         silentRequest.correlationId
@@ -2278,12 +2085,12 @@ export class StandardController implements IController {
                     const [activePromise, activeCorrelationId] =
                         this.activeIframeRequest;
                     this.logger.verbose(
-                        `Iframe request is already in progress, awaiting resolution for request with correlationId: ${activeCorrelationId}`,
+                        `Iframe request is already in progress, awaiting resolution for request with correlationId: '${activeCorrelationId}'`,
                         silentRequest.correlationId
                     );
                     const awaitConcurrentIframeMeasure =
                         this.performanceClient.startMeasurement(
-                            PerformanceEvents.AwaitConcurrentIframe,
+                            BrowserPerformanceEvents.AwaitConcurrentIframe,
                             silentRequest.correlationId
                         );
                     awaitConcurrentIframeMeasure.add({
@@ -2296,7 +2103,7 @@ export class StandardController implements IController {
                     });
                     if (activePromiseResult) {
                         this.logger.verbose(
-                            `Parallel iframe request with correlationId: ${activeCorrelationId} succeeded. Retrying cache and/or RT redemption`,
+                            `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
@@ -2306,7 +2113,8 @@ export class StandardController implements IController {
                         );
                     } else {
                         this.logger.info(
-                            `Iframe request with correlationId: ${activeCorrelationId} failed. Interaction is required.`
+                            `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;
@@ -2319,7 +2127,7 @@ export class StandardController implements IController {
                     );
                     return invokeAsync(
                         this.acquireTokenBySilentIframe.bind(this),
-                        PerformanceEvents.AcquireTokenBySilentIframe,
+                        BrowserPerformanceEvents.AcquireTokenBySilentIframe,
                         this.logger,
                         this.performanceClient,
                         silentRequest.correlationId
@@ -2338,12 +2146,15 @@ export class StandardController implements IController {
                     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;
             })
@@ -2379,16 +2190,14 @@ export class StandardController implements IController {
             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 },
+                "acquireTokenSilent - attempting to acquire token from native platform",
                 silentRequest.correlationId
             );
             return this.acquireTokenNative(
@@ -2397,17 +2206,11 @@ export class StandardController implements IController {
                 silentRequest.account.nativeAccountId,
                 cacheLookupPolicy
             ).catch(async (e: AuthError) => {
-                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"
+                        "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
@@ -2419,17 +2222,19 @@ export class StandardController implements IController {
             });
         } else {
             this.logger.verbose(
-                "acquireTokenSilent - attempting to acquire token from web flow"
+                "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"
+                    "acquireTokenSilent - cache lookup policy set to AccessToken, attempting to acquire token from local cache",
+                    silentRequest.correlationId
                 );
             }
             return invokeAsync(
                 this.acquireTokenFromCache.bind(this),
-                PerformanceEvents.AcquireTokenFromCache,
+                BrowserPerformanceEvents.AcquireTokenFromCache,
                 this.logger,
                 this.performanceClient,
                 silentRequest.correlationId
@@ -2447,7 +2252,7 @@ export class StandardController implements IController {
 
                     return invokeAsync(
                         this.acquireTokenByRefreshToken.bind(this),
-                        PerformanceEvents.AcquireTokenByRefreshToken,
+                        BrowserPerformanceEvents.AcquireTokenByRefreshToken,
                         this.logger,
                         this.performanceClient,
                         silentRequest.correlationId
@@ -2462,10 +2267,10 @@ export class StandardController implements IController {
      * @param correlationId
      */
     private async preGeneratePkceCodes(correlationId: string): Promise<void> {
-        this.logger.verbose("Generating new PKCE codes");
+        this.logger.verbose("Generating new PKCE codes", correlationId);
         this.pkceCode = await invokeAsync(
             generatePkceCodes,
-            PerformanceEvents.GeneratePkceCodes,
+            BrowserPerformanceEvents.GeneratePkceCodes,
             this.logger,
             this.performanceClient,
             correlationId
@@ -2480,11 +2285,15 @@ export class StandardController implements IController {
     private getPreGeneratedPkceCodes(
         correlationId: string
     ): PkceCodes | undefined {
-        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`
+            `'${res ? "Found" : "Did not find"}' pre-generated PKCE codes`,
+            correlationId
         );
         this.performanceClient.addFields(
             { usePreGeneratedPkce: !!res },
@@ -2494,7 +2303,8 @@ export class StandardController implements IController {
     }
 
     private logMultipleInstances(
-        performanceEvent: InProgressPerformanceEvent
+        performanceEvent: InProgressPerformanceEvent,
+        correlationId: string
     ): void {
         const clientId = this.config.auth.clientId;
 
@@ -2509,12 +2319,18 @@ export class StandardController implements IController {
 
         if (clientIds.length > 0) {
             this.logger.verbose(
-                "There is already an instance of MSAL.js in the window."
+                "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
+        );
     }
 }