plugin-data-source-mssql 2.0.5 → 2.0.7

package/dist/tedious/node_modules/@azure/msal-browser/src/controllers/StandardController.ts

@@ -7,35 +7,38 @@ 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,
     AuthToken,
+    enforceResourceParameter,
+    CacheHelpers,
+    TimeUtils,
 } 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,
 } from "../cache/BrowserCacheManager.js";
+import * as CacheKeys from "../cache/CacheKeys.js";
 import * as AccountManager from "../cache/AccountManager.js";
 import { BrowserConfiguration, CacheOptions } from "../config/Configuration.js";
 import {
@@ -59,12 +62,11 @@ import { EndSessionRequest } from "../request/EndSessionRequest.js";
 import { EndSessionPopupRequest } from "../request/EndSessionPopupRequest.js";
 import { INavigationClient } from "../navigation/INavigationClient.js";
 import { EventHandler } from "../event/EventHandler.js";
+import { base64Decode } from "../encode/Base64Decode.js";
 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 {
@@ -94,16 +96,19 @@ import {
 } from "../broker/nativeBroker/PlatformAuthProvider.js";
 import { IPlatformAuthHandler } from "../broker/nativeBroker/IPlatformAuthHandler.js";
 import { collectInstanceStats } from "../utils/MsalFrameStatsUtils.js";
+import { HandleRedirectPromiseOptions } from "../request/HandleRedirectPromiseOptions.js";
 
 function preflightCheck(
     initialized: boolean,
     performanceEvent: InProgressPerformanceEvent,
-    account?: AccountInfo
+    config: BrowserConfiguration,
+    request: RedirectRequest | PopupRequest | SsoSilentRequest | SilentRequest
 ) {
     try {
         BrowserUtils.preflightCheck(initialized);
+        enforceResourceParameter(config.auth.isMcp, request);
     } catch (e) {
-        performanceEvent.end({ success: false }, e, account);
+        performanceEvent.end({ success: false }, e, request.account);
         throw e;
     }
 }
@@ -130,9 +135,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;
 
@@ -249,11 +251,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,
@@ -264,23 +261,14 @@ export class StandardController implements IController {
             this.eventHandler
         );
 
-        // Initialize the token cache
-        this.tokenCache = new TokenCache(
-            this.config,
-            this.browserStorage,
-            this.logger,
-            this.browserCrypto,
-            this.performanceClient
-        );
-
         this.activeSilentTokenRequests = new Map();
 
         // Register listener functions
-        this.trackPageVisibility = this.trackPageVisibility.bind(this);
+        this.trackStateChange = this.trackStateChange.bind(this);
 
         // Register listener functions
-        this.trackPageVisibilityWithMeasurement =
-            this.trackPageVisibilityWithMeasurement.bind(this);
+        this.trackStateChangeWithMeasurement =
+            this.trackStateChangeWithMeasurement.bind(this);
     }
 
     static async createController(
@@ -292,63 +280,87 @@ export class StandardController implements IController {
         return controller;
     }
 
-    private trackPageVisibility(correlationId?: string): void {
+    private trackStateChange(
+        correlationId: string | undefined,
+        event: Event
+    ): void {
         if (!correlationId) {
             return;
         }
-        this.logger.info("Perf: Visibility change detected");
-        this.performanceClient.incrementFields(
-            { visibilityChangeCount: 1 },
-            correlationId
-        );
+
+        if (event.type === "visibilitychange") {
+            this.logger.info("Perf: Visibility change detected", correlationId);
+            this.performanceClient.incrementFields(
+                { visibilityChangeCount: 1 },
+                correlationId
+            );
+        } else if (event.type === "online") {
+            this.logger.info(
+                "Perf: Online status change detected",
+                correlationId
+            );
+            this.performanceClient.incrementFields(
+                { onlineStatusChangeCount: 1 },
+                correlationId
+            );
+        } else if (event.type === "offline") {
+            this.logger.info(
+                "Perf: Offline status change detected",
+                correlationId
+            );
+            this.performanceClient.incrementFields(
+                { onlineStatusChangeCount: 1 },
+                correlationId
+            );
+        }
     }
 
     /**
      * Initializer function to perform async startup tasks such as connecting to WAM extension
      * @param request {?InitializeApplicationRequest} correlation id
      */
-    async initialize(
-        request?: InitializeApplicationRequest,
-        isBroker?: boolean
-    ): Promise<void> {
-        this.logger.trace("initialize called");
+    async initialize(request?: InitializeApplicationRequest): Promise<void> {
+        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);
+            this.eventHandler.emitEvent(
+                EventType.INITIALIZE_END,
+                correlationId
+            );
             return;
         }
 
-        const initCorrelationId =
-            request?.correlationId || this.getRequestCorrelationId();
         const allowPlatformBroker = this.config.system.allowPlatformBroker;
         const initMeasurement = this.performanceClient.startMeasurement(
-            PerformanceEvents.InitializeClientApplication,
-            initCorrelationId
+            BrowserRootPerformanceEvents.InitializeClientApplication,
+            correlationId
         );
-        this.eventHandler.emitEvent(EventType.INITIALIZE_START);
+        this.eventHandler.emitEvent(EventType.INITIALIZE_START, correlationId);
 
         // Broker applications are initialized twice, so we avoid double-counting it
-        if (!isBroker) {
-            try {
-                this.logMultipleInstances(initMeasurement);
-            } catch {}
-        }
+        this.logMultipleInstances(initMeasurement, correlationId);
+        initMeasurement.add({ isMcp: this.config.auth.isMcp });
 
         await invokeAsync(
             this.browserStorage.initialize.bind(this.browserStorage),
-            PerformanceEvents.InitializeCache,
+            BrowserPerformanceEvents.InitializeCache,
             this.logger,
             this.performanceClient,
-            initCorrelationId
-        )(initCorrelationId);
+            correlationId
+        )(correlationId);
 
         if (allowPlatformBroker) {
             try {
@@ -356,35 +368,25 @@ export class StandardController implements IController {
                 this.platformAuthProvider = await getPlatformAuthProvider(
                     this.logger,
                     this.performanceClient,
-                    initCorrelationId,
-                    this.config.system.nativeBrokerHandshakeTimeout,
-                    this.config.system.allowPlatformBrokerWithDOM
+                    correlationId,
+                    this.config.system.nativeBrokerHandshakeTimeout
                 );
             } catch (e) {
-                this.logger.verbose(e as string);
+                this.logger.verbose(e as string, correlationId);
             }
         }
 
-        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 &&
-            (await this.preGeneratePkceCodes(initCorrelationId));
+        !this.config.system.navigatePopups &&
+            (await this.preGeneratePkceCodes(correlationId));
         this.initialized = true;
-        this.eventHandler.emitEvent(EventType.INITIALIZE_END);
+        this.eventHandler.emitEvent(EventType.INITIALIZE_END, correlationId);
         initMeasurement.end({
             allowPlatformBroker: allowPlatformBroker,
             success: true,
@@ -398,39 +400,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;
     }
@@ -441,11 +446,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;
         }
@@ -454,7 +460,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);
@@ -463,25 +470,28 @@ export class StandardController implements IController {
         const loggedInAccounts = this.getAllAccounts();
         const platformBrokerRequest: PlatformAuthRequest | null =
             this.browserStorage.getCachedNativeRequest();
-        const useNative =
-            platformBrokerRequest && this.platformAuthProvider && !hash;
+        const useNative = platformBrokerRequest && !options?.hash;
 
         let rootMeasurement: InProgressPerformanceEvent;
 
-        this.eventHandler.emitEvent(
-            EventType.HANDLE_REDIRECT_START,
-            InteractionType.Redirect
-        );
-
         let redirectResponse: Promise<AuthenticationResult | null>;
+        let cachedRedirectRequest: SsoSilentRequest | undefined;
         try {
             if (useNative && this.platformAuthProvider) {
+                const correlationId =
+                    platformBrokerRequest?.correlationId || "";
+                this.eventHandler.emitEvent(
+                    EventType.HANDLE_REDIRECT_START,
+                    correlationId,
+                    InteractionType.Redirect
+                );
                 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,
@@ -503,61 +513,71 @@ 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("");
+                cachedRedirectRequest = standardRequest;
                 const correlationId = standardRequest.correlationId;
+                this.eventHandler.emitEvent(
+                    EventType.HANDLE_REDIRECT_START,
+                    correlationId,
+                    InteractionType.Redirect
+                );
                 // 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,
+                        result.correlationId,
+                        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,
+                            result.correlationId,
                             InteractionType.Redirect,
-                            result
-                        );
-                        this.logger.verbose(
-                            "handleRedirectResponse returned result, login success"
-                        );
-                    } else {
-                        this.eventHandler.emitEvent(
-                            EventType.ACQUIRE_TOKEN_SUCCESS,
-                            InteractionType.Redirect,
-                            result
+                            result.account
                         );
                         this.logger.verbose(
-                            "handleRedirectResponse returned result, acquire token success"
+                            "handleRedirectResponse returned result, login success",
+                            result.correlationId
                         );
                     }
                     rootMeasurement.end(
@@ -567,6 +587,12 @@ export class StandardController implements IController {
                         undefined,
                         result.account
                     );
+
+                    // Fire-and-forget SSO capability verification in background
+                    this.verifySsoCapability(
+                        cachedRedirectRequest,
+                        InteractionType.Redirect
+                    );
                 } else {
                     /*
                      * Instrument an event only if an error code is set. Otherwise, discard it when the redirect response
@@ -581,32 +607,27 @@ export class StandardController implements IController {
 
                 this.eventHandler.emitEvent(
                     EventType.HANDLE_REDIRECT_END,
+                    rootMeasurement.event.correlationId,
                     InteractionType.Redirect
                 );
 
                 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,
+                    rootMeasurement.event.correlationId,
+                    InteractionType.Redirect,
+                    null,
+                    eventError
+                );
                 this.eventHandler.emitEvent(
                     EventType.HANDLE_REDIRECT_END,
+                    rootMeasurement.event.correlationId,
                     InteractionType.Redirect
                 );
 
@@ -636,75 +657,45 @@ export class StandardController implements IController {
         this.logger.verbose("acquireTokenRedirect called", correlationId);
 
         const atrMeasurement = this.performanceClient.startMeasurement(
-            PerformanceEvents.AcquireTokenPreRedirect,
+            BrowserRootPerformanceEvents.AcquireTokenPreRedirect,
             correlationId
         );
         atrMeasurement.add({
             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 },
+                    undefined,
+                    request.account
+                ) || atrMeasurement.event;
+            return navigate;
+        };
 
-        // If logged in, emit acquire token events
-        const isLoggedIn = this.getAllAccounts().length > 0;
         try {
             BrowserUtils.redirectPreflightCheck(this.initialized, this.config);
+            enforceResourceParameter(this.config.auth.isMcp, request);
             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,
+                correlationId,
+                InteractionType.Redirect,
+                request
+            );
 
             let result: Promise<void>;
 
@@ -726,32 +717,36 @@ 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
-                            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"
-                            );
-                            const redirectClient =
-                                this.createRedirectClient(correlationId);
-                            return redirectClient.acquireToken(request);
-                        }
-                        throw e;
+                result = invokeAsync(
+                    nativeClient.acquireTokenRedirect.bind(nativeClient),
+                    BrowserPerformanceEvents.NativeInteractionClientAcquireTokenRedirect,
+                    this.logger,
+                    this.performanceClient,
+                    correlationId
+                )(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
+                        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",
+                            correlationId
+                        );
+                        const redirectClient =
+                            this.createRedirectClient(correlationId);
+                        return redirectClient.acquireToken(request);
+                    }
+                    throw e;
+                });
             } else {
                 const redirectClient = this.createRedirectClient(correlationId);
                 result = redirectClient.acquireToken(request);
@@ -759,7 +754,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.
@@ -767,7 +762,7 @@ export class StandardController implements IController {
             if (atrMeasurement.event.status === 2) {
                 this.performanceClient
                     .startMeasurement(
-                        PerformanceEvents.AcquireTokenRedirect,
+                        BrowserRootPerformanceEvents.AcquireTokenRedirect,
                         correlationId
                     )
                     .end({ success: false }, e, request.account);
@@ -775,21 +770,13 @@ export class StandardController implements IController {
                 atrMeasurement.end({ success: false }, e, request.account);
             }
 
-            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,
+                correlationId,
+                InteractionType.Redirect,
+                null,
+                e as EventError
+            );
             throw e;
         }
     }
@@ -808,7 +795,7 @@ 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
         );
 
@@ -821,11 +808,14 @@ export class StandardController implements IController {
             preflightCheck(
                 this.initialized,
                 atPopupMeasurement,
-                request.account
+                this.config,
+                request
             );
             this.browserStorage.setInteractionInProgress(
                 true,
-                INTERACTION_TYPE.SIGNIN
+                INTERACTION_TYPE.SIGNIN,
+                request.overrideInteractionInProgress,
+                correlationId
             );
         } catch (e) {
             // Since this function is syncronous we need to reject
@@ -834,19 +824,12 @@ 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,
+            correlationId,
+            InteractionType.Popup,
+            request
+        );
 
         let result: Promise<AuthenticationResult>;
         const pkce = this.getPreGeneratedPkceCodes(correlationId);
@@ -866,6 +849,7 @@ export class StandardController implements IController {
                     atPopupMeasurement.end(
                         {
                             success: true,
+                            isNativeBroker: true,
                         },
                         undefined,
                         response.account
@@ -881,13 +865,14 @@ export class StandardController implements IController {
                         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 platform broker calls
                         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);
@@ -907,17 +892,18 @@ export class StandardController implements IController {
                  */
                 const isLoggingIn =
                     loggedInAccounts.length < this.getAllAccounts().length;
+                this.eventHandler.emitEvent(
+                    EventType.ACQUIRE_TOKEN_SUCCESS,
+                    correlationId,
+                    InteractionType.Popup,
+                    result
+                );
                 if (isLoggingIn) {
                     this.eventHandler.emitEvent(
                         EventType.LOGIN_SUCCESS,
+                        correlationId,
                         InteractionType.Popup,
-                        result
-                    );
-                } else {
-                    this.eventHandler.emitEvent(
-                        EventType.ACQUIRE_TOKEN_SUCCESS,
-                        InteractionType.Popup,
-                        result
+                        result.account
                     );
                 }
 
@@ -930,25 +916,20 @@ export class StandardController implements IController {
                     undefined,
                     result.account
                 );
+
+                // SSO capability verification in background
+                this.verifySsoCapability(request, InteractionType.Popup);
+
                 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,
+                    correlationId,
+                    InteractionType.Popup,
+                    null,
+                    e
+                );
                 atPopupMeasurement.end(
                     {
                         success: false,
@@ -962,13 +943,13 @@ 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);
                 }
             });
     }
 
-    private trackPageVisibilityWithMeasurement(): void {
+    private trackStateChangeWithMeasurement(event: Event): void {
         const measurement =
             this.ssoSilentMeasurement ||
             this.acquireTokenByCodeAsyncMeasurement;
@@ -976,14 +957,183 @@ export class StandardController implements IController {
             return;
         }
 
-        this.logger.info(
-            "Perf: Visibility change detected in ",
-            measurement.event.name
+        if (event.type === "visibilitychange") {
+            this.logger.info(
+                `Perf: Visibility change detected in '${measurement.event.name}'`,
+                measurement.event.correlationId
+            );
+            measurement.increment({
+                visibilityChangeCount: 1,
+            });
+        } else if (event.type === "online") {
+            this.logger.info(
+                `Perf: Online status change detected in '${measurement.event.name}'`,
+                measurement.event.correlationId
+            );
+            measurement.increment({
+                onlineStatusChangeCount: 1,
+            });
+        } else if (event.type === "offline") {
+            this.logger.info(
+                `Perf: Offline status change detected in '${measurement.event.name}'`,
+                measurement.event.correlationId
+            );
+            measurement.increment({
+                onlineStatusChangeCount: 1,
+            });
+        }
+    }
+
+    private addStateChangeListeners(listener: (event: Event) => void): void {
+        document.addEventListener("visibilitychange", listener);
+        window.addEventListener("online", listener);
+        window.addEventListener("offline", listener);
+    }
+
+    private removeStateChangeListeners(listener: (event: Event) => void): void {
+        document.removeEventListener("visibilitychange", listener);
+        window.removeEventListener("online", listener);
+        window.removeEventListener("offline", listener);
+    }
+
+    /**
+     * Reads the cached ssoCapable value from localStorage.
+     * @returns The cached ssoCapable boolean value, or undefined if not cached or expired.
+     */
+    private getCachedSsoCapable(): boolean | undefined {
+        try {
+            const cachedValue = window.localStorage.getItem(
+                CacheKeys.SSO_CAPABLE
+            );
+            if (cachedValue) {
+                const parsed = JSON.parse(cachedValue);
+                if (
+                    parsed &&
+                    typeof parsed.ssoCapable === "boolean" &&
+                    parsed.expiresOn &&
+                    Date.now() < parsed.expiresOn
+                ) {
+                    return parsed.ssoCapable;
+                }
+            }
+        } catch {
+            // If parsing fails, return undefined
+        }
+        return undefined;
+    }
+
+    /**
+     * SSO capability verification in the background.
+     * This method makes an iframe request to /authorize to verify SSO capability without calling /token.
+     * This method does not block the caller and tracks telemetry for success/failure.
+     * This method only executes if verifySSO is set to true in the auth configuration.
+     * The result is cached in localStorage with a 24-hour TTL; the SSO verification call
+     * is only attempted when the cached value is absent or expired.
+     * @param request - The original request used for the authentication flow
+     * @param interactionType - The interactionType of the AT operation for logging purposes
+     */
+    private verifySsoCapability(
+        request: SsoSilentRequest | undefined,
+        interactionType: InteractionType
+    ): void {
+        // Check if SSO capability verification is enabled
+        if (!this.config.auth.verifySSO) {
+            return;
+        }
+
+        // Check TTL: derive ssoCapable state from localStorage and skip if not expired
+        const ssoCacheKey = CacheKeys.SSO_CAPABLE;
+        const SSO_CAPABLE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+        const cachedSsoCapable = this.getCachedSsoCapable();
+        if (cachedSsoCapable !== undefined) {
+            this.logger.verbose(
+                `SSO capability verification skipped - cached value has not expired (interactionType: '${interactionType}')`,
+                ""
+            );
+            return;
+        }
+
+        const correlationId = createNewGuid();
+        const ssoCapableMeasurement = this.performanceClient.startMeasurement(
+            BrowserRootPerformanceEvents.SsoCapable,
+            correlationId
         );
-        measurement.increment({
-            visibilityChangeCount: 1,
+        ssoCapableMeasurement.add({
+            "ext.interactionType": interactionType,
         });
+
+        this.logger.verbose(
+            `SSO capability verification initiated after '${interactionType}'`,
+            correlationId
+        );
+
+        /*
+         * Use setTimeout to ensure this runs in a separate macrotask after the current call stack completes
+         * This ensures the result is returned to the caller before the SSO verification starts and doesn't affect performance
+         */
+        setTimeout(() => {
+            const ssoVerificationRequest: SsoSilentRequest = {
+                ...request,
+                correlationId: correlationId,
+            };
+
+            const silentIframeClient =
+                this.createSilentIframeClient(correlationId);
+            silentIframeClient
+                .verifySso(ssoVerificationRequest)
+                .then((result: boolean) => {
+                    this.logger.verbose(
+                        `SSO capability verification completed after '${interactionType}', result: '${result}'`,
+                        correlationId
+                    );
+
+                    // TBD to add profileTelemetry later in localStorage with 24h TTL
+                    try {
+                        const cacheEntry = JSON.stringify({
+                            ssoCapable: result,
+                            expiresOn: Date.now() + SSO_CAPABLE_TTL_MS,
+                        });
+                        window.localStorage.setItem(ssoCacheKey, cacheEntry);
+                    } catch {
+                        this.logger.warning(
+                            `Failed to cache SSO capability verification result (interactionType: '${interactionType}')`,
+                            correlationId
+                        );
+                    }
+
+                    ssoCapableMeasurement.end(
+                        {
+                            fromCache: false,
+                            success: result,
+                        },
+                        undefined
+                    );
+                })
+                .catch((error: Error) => {
+                    this.logger.warning(
+                        `SSO capability verification failed after '${interactionType}': '${error.message}'`,
+                        correlationId
+                    );
+                    // reset the cache
+                    try {
+                        window.localStorage.removeItem(ssoCacheKey);
+                    } catch {
+                        this.logger.warning(
+                            `Failed to reset cached SSO capability verification result (interactionType: '${interactionType}')`,
+                            correlationId
+                        );
+                    }
+                    ssoCapableMeasurement.end(
+                        {
+                            fromCache: false,
+                            success: false,
+                        },
+                        error
+                    );
+                });
+        }, 0);
     }
+
     // #endregion
 
     // #region Silent Flow
@@ -1007,33 +1157,34 @@ export class StandardController implements IController {
         const correlationId = this.getRequestCorrelationId(request);
         const validRequest = {
             ...request,
-            // will be PromptValue.NONE or PromptValue.NO_SESSION
-            prompt: request.prompt,
             correlationId: correlationId,
         };
         this.ssoSilentMeasurement = this.performanceClient.startMeasurement(
-            PerformanceEvents.SsoSilent,
+            BrowserRootPerformanceEvents.SsoSilent,
             correlationId
         );
         this.ssoSilentMeasurement?.add({
             scenarioId: request.scenarioId,
+            ssoCapable: this.getCachedSsoCapable(),
         });
         preflightCheck(
             this.initialized,
             this.ssoSilentMeasurement,
-            request.account
+            this.config,
+            validRequest
         );
         this.ssoSilentMeasurement?.increment({
             visibilityChangeCount: 0,
+            onlineStatusChangeCount: 0,
         });
 
-        document.addEventListener(
-            "visibilitychange",
-            this.trackPageVisibilityWithMeasurement
-        );
+        this.addStateChangeListeners(this.trackStateChangeWithMeasurement);
+
+        const loggedInAccounts = this.getAllAccounts();
         this.logger.verbose("ssoSilent called", correlationId);
         this.eventHandler.emitEvent(
-            EventType.SSO_SILENT_START,
+            EventType.ACQUIRE_TOKEN_START,
+            correlationId,
             InteractionType.Silent,
             validRequest
         );
@@ -1054,7 +1205,7 @@ export class StandardController implements IController {
                 });
                 // 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
+                    this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt platform broker calls
                     const silentIframeClient = this.createSilentIframeClient(
                         validRequest.correlationId
                     );
@@ -1071,14 +1222,26 @@ 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,
+                    correlationId,
                     InteractionType.Silent,
                     response
                 );
+                if (isLoggingIn) {
+                    this.eventHandler.emitEvent(
+                        EventType.LOGIN_SUCCESS,
+                        correlationId,
+                        InteractionType.Silent,
+                        response.account
+                    );
+                }
                 this.ssoSilentMeasurement?.end(
                     {
                         success: true,
+                        isNativeBroker: response.fromPlatformBroker,
                         accessTokenSize: response.accessToken.length,
                         idTokenSize: response.idToken.length,
                     },
@@ -1089,7 +1252,8 @@ export class StandardController implements IController {
             })
             .catch((e: Error) => {
                 this.eventHandler.emitEvent(
-                    EventType.SSO_SILENT_FAILURE,
+                    EventType.ACQUIRE_TOKEN_FAILURE,
+                    correlationId,
                     InteractionType.Silent,
                     null,
                     e
@@ -1104,9 +1268,8 @@ export class StandardController implements IController {
                 throw e;
             })
             .finally(() => {
-                document.removeEventListener(
-                    "visibilitychange",
-                    this.trackPageVisibilityWithMeasurement
+                this.removeStateChangeListeners(
+                    this.trackStateChangeWithMeasurement
                 );
             });
     }
@@ -1127,12 +1290,13 @@ 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);
+        preflightCheck(this.initialized, atbcMeasurement, this.config, request);
         this.eventHandler.emitEvent(
-            EventType.ACQUIRE_TOKEN_BY_CODE_START,
+            EventType.ACQUIRE_TOKEN_START,
+            correlationId,
             InteractionType.Silent,
             request
         );
@@ -1158,7 +1322,8 @@ export class StandardController implements IController {
                     })
                         .then((result: AuthenticationResult) => {
                             this.eventHandler.emitEvent(
-                                EventType.ACQUIRE_TOKEN_BY_CODE_SUCCESS,
+                                EventType.ACQUIRE_TOKEN_SUCCESS,
+                                correlationId,
                                 InteractionType.Silent,
                                 result
                             );
@@ -1177,7 +1342,8 @@ export class StandardController implements IController {
                         .catch((error: Error) => {
                             this.hybridAuthCodeResponses.delete(hybridAuthCode);
                             this.eventHandler.emitEvent(
-                                EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE,
+                                EventType.ACQUIRE_TOKEN_FAILURE,
+                                correlationId,
                                 InteractionType.Silent,
                                 null,
                                 error
@@ -1214,6 +1380,10 @@ export class StandardController implements IController {
                         ApiId.acquireTokenByCode,
                         request.nativeAccountId
                     ).catch((e: AuthError) => {
+                        atbcMeasurement.add({
+                            brokerErrorName: e.name,
+                            brokerErrorCode: e.errorCode,
+                        });
                         // If native token acquisition fails for availability reasons fallback to standard flow
                         if (
                             e instanceof NativeAuthError &&
@@ -1221,10 +1391,6 @@ 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(
@@ -1247,7 +1413,8 @@ export class StandardController implements IController {
             }
         } catch (e) {
             this.eventHandler.emitEvent(
-                EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE,
+                EventType.ACQUIRE_TOKEN_FAILURE,
+                correlationId,
                 InteractionType.Silent,
                 null,
                 e as EventError
@@ -1270,25 +1437,20 @@ 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,
+            onlineStatusChangeCount: 0,
         });
-        document.addEventListener(
-            "visibilitychange",
-            this.trackPageVisibilityWithMeasurement
-        );
-        const silentAuthCodeClient = this.createSilentAuthCodeClient(
-            request.correlationId
-        );
+        this.addStateChangeListeners(this.trackStateChangeWithMeasurement);
+        const silentAuthCodeClient =
+            this.createSilentAuthCodeClient(correlationId);
         const silentTokenResult = await silentAuthCodeClient
             .acquireToken(request)
             .then((response) => {
@@ -1308,9 +1470,8 @@ export class StandardController implements IController {
                 throw tokenRenewalError;
             })
             .finally(() => {
-                document.removeEventListener(
-                    "visibilitychange",
-                    this.trackPageVisibilityWithMeasurement
+                this.removeStateChangeListeners(
+                    this.trackStateChangeWithMeasurement
                 );
             });
         return silentTokenResult;
@@ -1327,10 +1488,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:
@@ -1340,7 +1497,7 @@ export class StandardController implements IController {
                 );
                 return invokeAsync(
                     silentCacheClient.acquireToken.bind(silentCacheClient),
-                    PerformanceEvents.SilentCacheClientAcquireToken,
+                    BrowserPerformanceEvents.SilentCacheClientAcquireToken,
                     this.logger,
                     this.performanceClient,
                     commonRequest.correlationId
@@ -1362,10 +1519,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:
@@ -1377,7 +1530,7 @@ export class StandardController implements IController {
 
                 return invokeAsync(
                     silentRefreshClient.acquireToken.bind(silentRefreshClient),
-                    PerformanceEvents.SilentRefreshClientAcquireToken,
+                    BrowserPerformanceEvents.SilentRefreshClientAcquireToken,
                     this.logger,
                     this.performanceClient,
                     commonRequest.correlationId
@@ -1397,18 +1550,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
@@ -1419,23 +1567,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`.
@@ -1482,7 +1613,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);
@@ -1500,12 +1630,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
         );
     }
@@ -1516,64 +1645,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
-        );
-    }
-
-    /**
-     * Returns the signed in account matching username.
-     * (the account object is created at the time of successful login)
-     * or null when no matching account is found.
-     * This API is provided for convenience but getAccountById should be used for best reliability
-     * @param username
-     * @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
-        );
-    }
-
-    /**
-     * Returns the signed in account matching homeAccountId.
-     * (the account object is created at the time of successful login)
-     * or null when no matching account is found
-     * @param homeAccountId
-     * @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
-        );
-    }
-
-    /**
-     * Returns the signed in account matching localAccountId.
-     * (the account object is created at the time of successful login)
-     * or null when no matching account is found
-     * @param localAccountId
-     * @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()
         );
     }
 
@@ -1582,11 +1658,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()
         );
     }
 
@@ -1594,10 +1669,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()
         );
     }
 
@@ -1617,14 +1691,15 @@ 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,
@@ -1632,12 +1707,61 @@ export class StandardController implements IController {
             ApiId.hydrateCache
         );
 
-        if (result.fromNativeBroker) {
+        if (result.fromPlatformBroker) {
             this.logger.verbose(
-                "Response was from native broker, storing in-memory"
+                "Response was from native broker, storing ID Token in browser storage and Access Token in-memory",
+                result.correlationId
+            );
+
+            // Create idToken entity and store in browser storage
+            const idTokenEntity = CacheHelpers.createIdTokenEntity(
+                result.account.homeAccountId,
+                result.account.environment,
+                result.idToken,
+                this.config.auth.clientId,
+                result.tenantId
+            );
+
+            // Create accessToken entity and store in native internal storage
+            const accessTokenEntity = CacheHelpers.createAccessTokenEntity(
+                result.account.homeAccountId,
+                result.account.environment,
+                result.accessToken,
+                this.config.auth.clientId,
+                result.tenantId,
+                result.scopes.join(" "),
+                result.expiresOn
+                    ? TimeUtils.toSecondsFromDate(result.expiresOn)
+                    : 0,
+                result.extExpiresOn
+                    ? TimeUtils.toSecondsFromDate(result.extExpiresOn)
+                    : 0,
+                base64Decode,
+                undefined, // refreshOn
+                result.tokenType as Constants.AuthenticationScheme,
+                undefined, // userAssertionHash
+                request.sshKid
+            );
+
+            if (request.resource) {
+                accessTokenEntity.resource = request.resource;
+            }
+
+            const kmsi = AuthToken.isKmsi(result.idTokenClaims);
+
+            // Store idToken in browser storage
+            await this.browserStorage.setIdTokenCredential(
+                idTokenEntity,
+                result.correlationId,
+                kmsi
+            );
+
+            // Store accessToken in native internal storage
+            await this.nativeInternalStorage.setAccessTokenCredential(
+                accessTokenEntity,
+                result.correlationId,
+                kmsi
             );
-            // Tokens from native broker are stored in-memory
-            return this.nativeInternalStorage.hydrateCache(result, request);
         } else {
             return this.browserStorage.hydrateCache(result, request);
         }
@@ -1655,12 +1779,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,
@@ -1673,10 +1799,16 @@ export class StandardController implements IController {
             this.platformAuthProvider,
             accountId || this.getNativeAccountId(request),
             this.nativeInternalStorage,
-            request.correlationId
+            correlationId
         );
 
-        return nativeClient.acquireToken(request, cacheLookupPolicy);
+        return invokeAsync(
+            nativeClient.acquireToken.bind(nativeClient),
+            BrowserPerformanceEvents.NativeInteractionClientAcquireToken,
+            this.logger,
+            this.performanceClient,
+            correlationId
+        )(request, cacheLookupPolicy);
     }
 
     /**
@@ -1687,10 +1819,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;
         }
@@ -1699,29 +1833,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: isPlatformAuthAllowed 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;
             }
@@ -1729,7 +1866,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;
         }
@@ -1751,7 +1889,9 @@ export class StandardController implements IController {
                 loginHint: request.loginHint,
                 sid: request.sid,
             }) ||
-            this.getActiveAccount();
+            (!request.loginHint && !request.sid
+                ? this.getActiveAccount()
+                : null);
 
         return (account && account.nativeAccountId) || "";
     }
@@ -1760,7 +1900,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,
@@ -1770,8 +1910,8 @@ export class StandardController implements IController {
             this.navigationClient,
             this.performanceClient,
             this.nativeInternalStorage,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1779,7 +1919,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,
@@ -1789,8 +1929,8 @@ export class StandardController implements IController {
             this.navigationClient,
             this.performanceClient,
             this.nativeInternalStorage,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1798,9 +1938,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,
@@ -1811,8 +1949,8 @@ export class StandardController implements IController {
             ApiId.ssoSilent,
             this.performanceClient,
             this.nativeInternalStorage,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1820,7 +1958,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,
@@ -1830,8 +1968,8 @@ export class StandardController implements IController {
             this.eventHandler,
             this.navigationClient,
             this.performanceClient,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1839,7 +1977,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,
@@ -1849,8 +1987,8 @@ export class StandardController implements IController {
             this.eventHandler,
             this.navigationClient,
             this.performanceClient,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1858,7 +1996,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,
@@ -1869,8 +2007,8 @@ export class StandardController implements IController {
             this.navigationClient,
             ApiId.acquireTokenByCode,
             this.performanceClient,
-            this.platformAuthProvider,
-            correlationId
+            correlationId,
+            this.platformAuthProvider
         );
     }
 
@@ -1914,49 +2052,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
      */
@@ -2033,7 +2128,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
@@ -2083,15 +2178,16 @@ export class StandardController implements IController {
     ): Promise<AuthenticationResult> {
         const correlationId = this.getRequestCorrelationId(request);
         const atsMeasurement = this.performanceClient.startMeasurement(
-            PerformanceEvents.AcquireTokenSilent,
+            BrowserRootPerformanceEvents.AcquireTokenSilent,
             correlationId
         );
         atsMeasurement.add({
             cacheLookupPolicy: request.cacheLookupPolicy,
             scenarioId: request.scenarioId,
+            ssoCapable: this.getCachedSsoCapable(),
         });
 
-        preflightCheck(this.initialized, atsMeasurement, request.account);
+        preflightCheck(this.initialized, atsMeasurement, this.config, request);
         this.logger.verbose("acquireTokenSilent called", correlationId);
 
         const account = request.account || this.getActiveAccount();
@@ -2169,7 +2265,7 @@ export class StandardController implements IController {
 
             const activeRequest = invokeAsync(
                 this.acquireTokenSilentAsync.bind(this),
-                PerformanceEvents.AcquireTokenSilentAsync,
+                BrowserPerformanceEvents.AcquireTokenSilentAsync,
                 this.logger,
                 this.performanceClient,
                 correlationId
@@ -2205,31 +2301,27 @@ export class StandardController implements IController {
         request: SilentRequest & { correlationId: string },
         account: AccountInfo
     ): Promise<AuthenticationResult> {
-        const trackPageVisibility = () =>
-            this.trackPageVisibility(request.correlationId);
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.AcquireTokenSilentAsync,
-            request.correlationId
-        );
-
+        const trackStateChange = (event: Event) =>
+            this.trackStateChange(request.correlationId, event);
         this.eventHandler.emitEvent(
             EventType.ACQUIRE_TOKEN_START,
+            request.correlationId,
             InteractionType.Silent,
             request
         );
 
         if (request.correlationId) {
             this.performanceClient.incrementFields(
-                { visibilityChangeCount: 0 },
+                { visibilityChangeCount: 0, onlineStatusChangeCount: 0 },
                 request.correlationId
             );
         }
 
-        document.addEventListener("visibilitychange", trackPageVisibility);
+        this.addStateChangeListeners(trackStateChange);
 
         const silentRequest = await invokeAsync(
             initializeSilentRequest,
-            PerformanceEvents.InitializeSilentRequest,
+            BrowserPerformanceEvents.InitializeSilentRequest,
             this.logger,
             this.performanceClient,
             request.correlationId
@@ -2248,6 +2340,15 @@ export class StandardController implements IController {
                 );
 
             if (shouldTryToResolveSilently) {
+                const silentRefreshReason = `${refreshTokenError.errorCode}${
+                    refreshTokenError.subError
+                        ? `|${refreshTokenError.subError}`
+                        : ""
+                }`;
+                this.performanceClient.addFields(
+                    { silentRefreshReason },
+                    request.correlationId
+                );
                 if (!this.activeIframeRequest) {
                     let _resolve: (result: boolean) => void;
                     // Always set the active request tracker immediately after checking it to prevent races
@@ -2263,7 +2364,7 @@ export class StandardController implements IController {
                     );
                     return invokeAsync(
                         this.acquireTokenBySilentIframe.bind(this),
-                        PerformanceEvents.AcquireTokenBySilentIframe,
+                        BrowserPerformanceEvents.AcquireTokenBySilentIframe,
                         this.logger,
                         this.performanceClient,
                         silentRequest.correlationId
@@ -2283,12 +2384,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({
@@ -2301,7 +2402,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
@@ -2311,7 +2412,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;
@@ -2324,7 +2426,7 @@ export class StandardController implements IController {
                     );
                     return invokeAsync(
                         this.acquireTokenBySilentIframe.bind(this),
-                        PerformanceEvents.AcquireTokenBySilentIframe,
+                        BrowserPerformanceEvents.AcquireTokenBySilentIframe,
                         this.logger,
                         this.performanceClient,
                         silentRequest.correlationId
@@ -2340,21 +2442,26 @@ export class StandardController implements IController {
             .then((response) => {
                 this.eventHandler.emitEvent(
                     EventType.ACQUIRE_TOKEN_SUCCESS,
+                    request.correlationId,
                     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: Error) => {
                 this.eventHandler.emitEvent(
                     EventType.ACQUIRE_TOKEN_FAILURE,
+                    request.correlationId,
                     InteractionType.Silent,
                     null,
                     tokenRenewalError
@@ -2362,10 +2469,7 @@ export class StandardController implements IController {
                 throw tokenRenewalError;
             })
             .finally(() => {
-                document.removeEventListener(
-                    "visibilitychange",
-                    trackPageVisibility
-                );
+                this.removeStateChangeListeners(trackStateChange);
             });
     }
 
@@ -2384,18 +2488,22 @@ 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"
+                "acquireTokenSilent - attempting to acquire token from native platform",
+                silentRequest.correlationId
             );
+
             this.performanceClient.addFields(
                 { isPlatformBrokerRequest: true },
                 silentRequest.correlationId
             );
+
             return this.acquireTokenNative(
                 silentRequest,
                 ApiId.acquireTokenSilent_silentFlow,
@@ -2409,10 +2517,12 @@ export class StandardController implements IController {
                     },
                     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
@@ -2424,17 +2534,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
@@ -2446,13 +2558,14 @@ export class StandardController implements IController {
 
                     this.eventHandler.emitEvent(
                         EventType.ACQUIRE_TOKEN_NETWORK_START,
+                        silentRequest.correlationId,
                         InteractionType.Silent,
                         silentRequest
                     );
 
                     return invokeAsync(
                         this.acquireTokenByRefreshToken.bind(this),
-                        PerformanceEvents.AcquireTokenByRefreshToken,
+                        BrowserPerformanceEvents.AcquireTokenByRefreshToken,
                         this.logger,
                         this.performanceClient,
                         silentRequest.correlationId
@@ -2467,10 +2580,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
@@ -2485,12 +2598,20 @@ export class StandardController implements IController {
     private getPreGeneratedPkceCodes(
         correlationId: string
     ): PkceCodes | undefined {
-        this.logger.verbose("Attempting to pick up pre-generated PKCE codes");
         const res = this.pkceCode ? { ...this.pkceCode } : undefined;
         this.pkceCode = undefined;
-        this.logger.verbose(
-            `${res ? "Found" : "Did not find"} pre-generated PKCE codes`
-        );
+        if (res) {
+            this.logger.verbose(
+                `Pre-generated PKCE codes were found`,
+                correlationId
+            );
+        } else {
+            this.logger.verbose(
+                `Pre-generated PKCE codes were not found`,
+                correlationId
+            );
+        }
+
         this.performanceClient.addFields(
             { usePreGeneratedPkce: !!res },
             correlationId
@@ -2499,7 +2620,8 @@ export class StandardController implements IController {
     }
 
     private logMultipleInstances(
-        performanceEvent: InProgressPerformanceEvent
+        performanceEvent: InProgressPerformanceEvent,
+        correlationId: string
     ): void {
         const clientId = this.config.auth.clientId;
 
@@ -2514,12 +2636,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
+        );
     }
 }