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

package/src/interaction_client/RedirectClient.ts

@@ -8,7 +8,6 @@ import {
     UrlString,
     AuthError,
     ServerTelemetryManager,
-    Constants,
     AuthorizeResponse,
     ICrypto,
     Logger,
@@ -16,13 +15,16 @@ import {
     PerformanceEvents,
     ProtocolMode,
     invokeAsync,
-    ServerResponseType,
+    Constants,
     UrlUtils,
     InProgressPerformanceEvent,
     CommonAuthorizationUrlRequest,
-    HttpMethod,
 } from "@azure/msal-common/browser";
-import { StandardInteractionClient } from "./StandardInteractionClient.js";
+import {
+    initializeAuthorizationRequest,
+    StandardInteractionClient,
+} from "./StandardInteractionClient.js";
+import * as BrowserPerformanceEvents from "../telemetry/BrowserPerformanceEvents.js";
 import {
     ApiId,
     INTERACTION_TYPE,
@@ -50,6 +52,12 @@ import { generatePkceCodes } from "../crypto/PkceGenerator.js";
 import { isPlatformAuthAllowed } from "../broker/nativeBroker/PlatformAuthProvider.js";
 import { generateEarKey } from "../crypto/BrowserCrypto.js";
 import { IPlatformAuthHandler } from "../broker/nativeBroker/IPlatformAuthHandler.js";
+import {
+    clearCacheOnLogout,
+    getDiscoveredAuthority,
+    initializeServerTelemetryManager,
+} from "./BaseInteractionClient.js";
+import { HandleRedirectPromiseOptions } from "../controllers/IController.js";
 
 function getNavigationType(): NavigationTimingType | undefined {
     if (
@@ -79,8 +87,8 @@ export class RedirectClient extends StandardInteractionClient {
         navigationClient: INavigationClient,
         performanceClient: IPerformanceClient,
         nativeStorageImpl: BrowserCacheManager,
-        platformAuthHandler?: IPlatformAuthHandler,
-        correlationId?: string
+        correlationId: string,
+        platformAuthHandler?: IPlatformAuthHandler
     ) {
         super(
             config,
@@ -90,8 +98,8 @@ export class RedirectClient extends StandardInteractionClient {
             eventHandler,
             navigationClient,
             performanceClient,
-            platformAuthHandler,
-            correlationId
+            correlationId,
+            platformAuthHandler
         );
         this.nativeStorage = nativeStorageImpl;
     }
@@ -102,16 +110,26 @@ export class RedirectClient extends StandardInteractionClient {
      */
     async acquireToken(request: RedirectRequest): Promise<void> {
         const validRequest = await invokeAsync(
-            this.initializeAuthorizationRequest.bind(this),
-            PerformanceEvents.StandardInteractionClientInitializeAuthorizationRequest,
+            initializeAuthorizationRequest,
+            BrowserPerformanceEvents.StandardInteractionClientInitializeAuthorizationRequest,
             this.logger,
             this.performanceClient,
             this.correlationId
-        )(request, InteractionType.Redirect);
+        )(
+            request,
+            InteractionType.Redirect,
+            this.config,
+            this.browserCrypto,
+            this.browserStorage,
+            this.logger,
+            this.performanceClient,
+            this.correlationId
+        );
 
         validRequest.platformBroker = isPlatformAuthAllowed(
             this.config,
             this.logger,
+            this.correlationId,
             this.platformAuthProvider,
             request.authenticationScheme
         );
@@ -120,9 +138,10 @@ export class RedirectClient extends StandardInteractionClient {
             // Clear temporary cache if the back button is clicked during the redirect flow.
             if (event.persisted) {
                 this.logger.verbose(
-                    "Page was restored from back/forward cache. Clearing temporary cache."
+                    "Page was restored from back/forward cache. Clearing temporary cache.",
+                    this.correlationId
                 );
-                this.browserStorage.resetRequestCache();
+                this.browserStorage.resetRequestCache(this.correlationId);
                 this.eventHandler.emitEvent(
                     EventType.RESTORE_FROM_BFCACHE,
                     InteractionType.Redirect
@@ -133,7 +152,10 @@ export class RedirectClient extends StandardInteractionClient {
         const redirectStartPage = this.getRedirectStartPage(
             request.redirectStartPage
         );
-        this.logger.verbosePii(`Redirect start page: ${redirectStartPage}`);
+        this.logger.verbosePii(
+            `Redirect start page: '${redirectStartPage}'`,
+            this.correlationId
+        );
         // Cache start page, returns to this page after redirectUri if navigateToLoginRequestUrl is true
         this.browserStorage.setTemporaryCache(
             TemporaryCacheKeys.ORIGIN_URI,
@@ -145,13 +167,10 @@ export class RedirectClient extends StandardInteractionClient {
         window.addEventListener("pageshow", handleBackButton);
 
         try {
-            if (this.config.auth.protocolMode === ProtocolMode.EAR) {
+            if (this.config.system.protocolMode === ProtocolMode.EAR) {
                 await this.executeEarFlow(validRequest);
             } else {
-                await this.executeCodeFlow(
-                    validRequest,
-                    request.onRedirectNavigate
-                );
+                await this.executeCodeFlow(validRequest);
             }
         } catch (e) {
             if (e instanceof AuthError) {
@@ -168,17 +187,20 @@ export class RedirectClient extends StandardInteractionClient {
      * @returns
      */
     async executeCodeFlow(
-        request: CommonAuthorizationUrlRequest,
-        onRedirectNavigate?: (url: string) => boolean | void
+        request: CommonAuthorizationUrlRequest
     ): Promise<void> {
         const correlationId = request.correlationId;
-        const serverTelemetryManager = this.initializeServerTelemetryManager(
-            ApiId.acquireTokenRedirect
+        const serverTelemetryManager = initializeServerTelemetryManager(
+            ApiId.acquireTokenRedirect,
+            this.config.auth.clientId,
+            this.correlationId,
+            this.browserStorage,
+            this.logger
         );
 
         const pkceCodes = await invokeAsync(
             generatePkceCodes,
-            PerformanceEvents.GeneratePkceCodes,
+            BrowserPerformanceEvents.GeneratePkceCodes,
             this.logger,
             this.performanceClient,
             correlationId
@@ -191,49 +213,43 @@ export class RedirectClient extends StandardInteractionClient {
 
         this.browserStorage.cacheAuthorizeRequest(
             redirectRequest,
+            this.correlationId,
             pkceCodes.verifier
         );
 
         try {
-            if (redirectRequest.httpMethod === HttpMethod.POST) {
-                return await this.executeCodeFlowWithPost(redirectRequest);
-            } else {
-                // Initialize the client
-                const authClient: AuthorizationCodeClient = await invokeAsync(
-                    this.createAuthCodeClient.bind(this),
-                    PerformanceEvents.StandardInteractionClientCreateAuthCodeClient,
-                    this.logger,
-                    this.performanceClient,
-                    this.correlationId
-                )({
-                    serverTelemetryManager,
-                    requestAuthority: redirectRequest.authority,
-                    requestAzureCloudOptions: redirectRequest.azureCloudOptions,
-                    requestExtraQueryParameters:
-                        redirectRequest.extraQueryParameters,
-                    account: redirectRequest.account,
-                });
-
-                // Create acquire token url.
-                const navigateUrl = await invokeAsync(
-                    Authorize.getAuthCodeRequestUrl,
-                    PerformanceEvents.GetAuthCodeUrl,
-                    this.logger,
-                    this.performanceClient,
-                    request.correlationId
-                )(
-                    this.config,
-                    authClient.authority,
-                    redirectRequest,
-                    this.logger,
-                    this.performanceClient
-                );
-                // Show the UI once the url has been created. Response will come back in the hash, which will be handled in the handleRedirectCallback function.
-                return await this.initiateAuthRequest(
-                    navigateUrl,
-                    onRedirectNavigate
-                );
-            }
+            // Initialize the client
+            const authClient: AuthorizationCodeClient = await invokeAsync(
+                this.createAuthCodeClient.bind(this),
+                BrowserPerformanceEvents.StandardInteractionClientCreateAuthCodeClient,
+                this.logger,
+                this.performanceClient,
+                this.correlationId
+            )({
+                serverTelemetryManager,
+                requestAuthority: redirectRequest.authority,
+                requestAzureCloudOptions: redirectRequest.azureCloudOptions,
+                requestExtraQueryParameters:
+                    redirectRequest.extraQueryParameters,
+                account: redirectRequest.account,
+            });
+
+            // Create acquire token url.
+            const navigateUrl = await invokeAsync(
+                Authorize.getAuthCodeRequestUrl,
+                PerformanceEvents.GetAuthCodeUrl,
+                this.logger,
+                this.performanceClient,
+                request.correlationId
+            )(
+                this.config,
+                authClient.authority,
+                redirectRequest,
+                this.logger,
+                this.performanceClient
+            );
+            // Show the UI once the url has been created. Response will come back in the hash, which will be handled in the handleRedirectCallback function.
+            return await this.initiateAuthRequest(navigateUrl);
         } catch (e) {
             if (e instanceof AuthError) {
                 e.setCorrelationId(this.correlationId);
@@ -250,24 +266,35 @@ export class RedirectClient extends StandardInteractionClient {
     async executeEarFlow(
         request: CommonAuthorizationUrlRequest
     ): Promise<void> {
-        const correlationId = request.correlationId;
+        const {
+            correlationId,
+            authority,
+            azureCloudOptions,
+            extraQueryParameters,
+            account,
+        } = request;
         // Get the frame handle for the silent request
         const discoveredAuthority = await invokeAsync(
-            this.getDiscoveredAuthority.bind(this),
-            PerformanceEvents.StandardInteractionClientGetDiscoveredAuthority,
+            getDiscoveredAuthority,
+            BrowserPerformanceEvents.StandardInteractionClientGetDiscoveredAuthority,
             this.logger,
             this.performanceClient,
             correlationId
-        )({
-            requestAuthority: request.authority,
-            requestAzureCloudOptions: request.azureCloudOptions,
-            requestExtraQueryParameters: request.extraQueryParameters,
-            account: request.account,
-        });
+        )(
+            this.config,
+            this.correlationId,
+            this.performanceClient,
+            this.browserStorage,
+            this.logger,
+            authority,
+            azureCloudOptions,
+            extraQueryParameters,
+            account
+        );
 
         const earJwk = await invokeAsync(
             generateEarKey,
-            PerformanceEvents.GenerateEarKey,
+            BrowserPerformanceEvents.GenerateEarKey,
             this.logger,
             this.performanceClient,
             correlationId
@@ -276,62 +303,19 @@ export class RedirectClient extends StandardInteractionClient {
             ...request,
             earJwk: earJwk,
         };
-        this.browserStorage.cacheAuthorizeRequest(redirectRequest);
-
-        const form = await Authorize.getEARForm(
-            document,
-            this.config,
-            discoveredAuthority,
+        this.browserStorage.cacheAuthorizeRequest(
             redirectRequest,
-            this.logger,
-            this.performanceClient
+            this.correlationId
         );
-        form.submit();
-        return new Promise<void>((resolve, reject) => {
-            setTimeout(() => {
-                reject(
-                    createBrowserAuthError(
-                        BrowserAuthErrorCodes.timedOut,
-                        "failed_to_redirect"
-                    )
-                );
-            }, this.config.system.redirectNavigationTimeout);
-        });
-    }
-
-    /**
-     * Executes classic Authorization Code flow with a POST request.
-     * @param request
-     */
-    async executeCodeFlowWithPost(
-        request: CommonAuthorizationUrlRequest
-    ): Promise<void> {
-        const correlationId = request.correlationId;
-        // Get the frame handle for the silent request
-        const discoveredAuthority = await invokeAsync(
-            this.getDiscoveredAuthority.bind(this),
-            PerformanceEvents.StandardInteractionClientGetDiscoveredAuthority,
-            this.logger,
-            this.performanceClient,
-            correlationId
-        )({
-            requestAuthority: request.authority,
-            requestAzureCloudOptions: request.azureCloudOptions,
-            requestExtraQueryParameters: request.extraQueryParameters,
-            account: request.account,
-        });
-
-        this.browserStorage.cacheAuthorizeRequest(request);
 
-        const form = await Authorize.getCodeForm(
+        const form = await Authorize.getEARForm(
             document,
             this.config,
             discoveredAuthority,
-            request,
+            redirectRequest,
             this.logger,
             this.performanceClient
         );
-
         form.submit();
         return new Promise<void>((resolve, reject) => {
             setTimeout(() => {
@@ -351,34 +335,46 @@ export class RedirectClient extends StandardInteractionClient {
      * - if false, handles hash string and parses response
      * @param hash {string} url hash
      * @param parentMeasurement {InProgressPerformanceEvent} parent measurement
+     * @param request {CommonAuthorizationUrlRequest} request object
+     * @param pkceVerifier {string} PKCE verifier
+     * @param options {HandleRedirectPromiseOptions} options for handling redirect promise
      */
     async handleRedirectPromise(
-        hash: string = "",
         request: CommonAuthorizationUrlRequest,
         pkceVerifier: string,
-        parentMeasurement: InProgressPerformanceEvent
+        parentMeasurement: InProgressPerformanceEvent,
+        options?: HandleRedirectPromiseOptions
     ): Promise<AuthenticationResult | null> {
-        const serverTelemetryManager = this.initializeServerTelemetryManager(
-            ApiId.handleRedirectPromise
+        const serverTelemetryManager = initializeServerTelemetryManager(
+            ApiId.handleRedirectPromise,
+            this.config.auth.clientId,
+            this.correlationId,
+            this.browserStorage,
+            this.logger
         );
 
+        const navigateToLoginRequestUrl =
+            options?.navigateToLoginRequestUrl ?? true;
+
         try {
             const [serverParams, responseString] = this.getRedirectResponse(
-                hash || ""
+                options?.hash || ""
             );
             if (!serverParams) {
                 // Not a recognized server response hash or hash not associated with a redirect request
                 this.logger.info(
-                    "handleRedirectPromise did not detect a response as a result of a redirect. Cleaning temporary cache."
+                    "handleRedirectPromise did not detect a response as a result of a redirect. Cleaning temporary cache.",
+                    this.correlationId
                 );
-                this.browserStorage.resetRequestCache();
+                this.browserStorage.resetRequestCache(this.correlationId);
 
                 // Do not instrument "no_server_response" if user clicked back button
                 if (getNavigationType() !== "back_forward") {
                     parentMeasurement.event.errorCode = "no_server_response";
                 } else {
                     this.logger.verbose(
-                        "Back navigation event detected. Muting no_server_response error"
+                        "Back navigation event detected. Muting no_server_response error",
+                        this.correlationId
                     );
                 }
                 return null;
@@ -388,8 +384,9 @@ export class RedirectClient extends StandardInteractionClient {
             const loginRequestUrl =
                 this.browserStorage.getTemporaryCache(
                     TemporaryCacheKeys.ORIGIN_URI,
+                    this.correlationId,
                     true
-                ) || Constants.EMPTY_STRING;
+                ) || "";
             const loginRequestUrlNormalized =
                 UrlUtils.normalizeUrlForComparison(loginRequestUrl);
             const currentUrlNormalized = UrlUtils.normalizeUrlForComparison(
@@ -398,11 +395,12 @@ export class RedirectClient extends StandardInteractionClient {
 
             if (
                 loginRequestUrlNormalized === currentUrlNormalized &&
-                this.config.auth.navigateToLoginRequestUrl
+                navigateToLoginRequestUrl
             ) {
                 // We are on the page we need to navigate to - handle hash
                 this.logger.verbose(
-                    "Current page is loginRequestUrl, handling response"
+                    "Current page is loginRequestUrl, handling response",
+                    this.correlationId
                 );
 
                 if (loginRequestUrl.indexOf("#") > -1) {
@@ -418,9 +416,10 @@ export class RedirectClient extends StandardInteractionClient {
                 );
 
                 return handleHashResult;
-            } else if (!this.config.auth.navigateToLoginRequestUrl) {
+            } else if (!navigateToLoginRequestUrl) {
                 this.logger.verbose(
-                    "NavigateToLoginRequestUrl set to false, handling response"
+                    "NavigateToLoginRequestUrl set to false, handling response",
+                    this.correlationId
                 );
                 return await this.handleResponse(
                     serverParams,
@@ -462,7 +461,8 @@ export class RedirectClient extends StandardInteractionClient {
                         true
                     );
                     this.logger.warning(
-                        "Unable to get valid login request url from cache, redirecting to home page"
+                        "Unable to get valid login request url from cache, redirecting to home page",
+                        this.correlationId
                     );
                     processHashOnRedirect =
                         await this.navigationClient.navigateInternal(
@@ -472,7 +472,8 @@ export class RedirectClient extends StandardInteractionClient {
                 } else {
                     // Navigate to page that initiated the redirect request
                     this.logger.verbose(
-                        `Navigating to loginRequestUrl: ${loginRequestUrl}`
+                        `Navigating to loginRequestUrl: '${loginRequestUrl}'`,
+                        this.correlationId
                     );
                     processHashOnRedirect =
                         await this.navigationClient.navigateInternal(
@@ -510,13 +511,16 @@ export class RedirectClient extends StandardInteractionClient {
     protected getRedirectResponse(
         userProvidedResponse: string
     ): [AuthorizeResponse | null, string] {
-        this.logger.verbose("getRedirectResponseHash called");
+        this.logger.verbose(
+            "getRedirectResponseHash called",
+            this.correlationId
+        );
         // Get current location hash from window or cache.
         let responseString = userProvidedResponse;
         if (!responseString) {
             if (
-                this.config.auth.OIDCOptions.serverResponseType ===
-                ServerResponseType.QUERY
+                this.config.auth.OIDCOptions.responseMode ===
+                Constants.ResponseMode.QUERY
             ) {
                 responseString = window.location.search;
             } else {
@@ -535,7 +539,8 @@ export class RedirectClient extends StandardInteractionClient {
             } catch (e) {
                 if (e instanceof AuthError) {
                     this.logger.error(
-                        `Interaction type validation failed due to ${e.errorCode}: ${e.errorMessage}`
+                        `Interaction type validation failed due to '${e.errorCode}': '${e.errorMessage}'`,
+                        this.correlationId
                     );
                 }
                 return [null, ""];
@@ -543,13 +548,15 @@ export class RedirectClient extends StandardInteractionClient {
 
             BrowserUtils.clearHash(window);
             this.logger.verbose(
-                "Hash contains known properties, returning response hash"
+                "Hash contains known properties, returning response hash",
+                this.correlationId
             );
             return [response, responseString];
         }
 
         const cachedHash = this.browserStorage.getTemporaryCache(
             TemporaryCacheKeys.URL_HASH,
+            this.correlationId,
             true
         );
         this.browserStorage.removeItem(
@@ -560,7 +567,8 @@ export class RedirectClient extends StandardInteractionClient {
             response = UrlUtils.getDeserializedResponse(cachedHash);
             if (response) {
                 this.logger.verbose(
-                    "Hash does not contain known properties, returning cached hash"
+                    "Hash does not contain known properties, returning cached hash",
+                    this.correlationId
                 );
                 return [response, cachedHash];
             }
@@ -585,22 +593,30 @@ export class RedirectClient extends StandardInteractionClient {
             throw createBrowserAuthError(BrowserAuthErrorCodes.noStateInHash);
         }
 
+        const { authority, azureCloudOptions, extraQueryParameters, account } =
+            request;
+
         if (serverParams.ear_jwe) {
             const discoveredAuthority = await invokeAsync(
-                this.getDiscoveredAuthority.bind(this),
-                PerformanceEvents.StandardInteractionClientGetDiscoveredAuthority,
+                getDiscoveredAuthority,
+                BrowserPerformanceEvents.StandardInteractionClientGetDiscoveredAuthority,
                 this.logger,
                 this.performanceClient,
                 request.correlationId
-            )({
-                requestAuthority: request.authority,
-                requestAzureCloudOptions: request.azureCloudOptions,
-                requestExtraQueryParameters: request.extraQueryParameters,
-                account: request.account,
-            });
+            )(
+                this.config,
+                this.correlationId,
+                this.performanceClient,
+                this.browserStorage,
+                this.logger,
+                authority,
+                azureCloudOptions,
+                extraQueryParameters,
+                account
+            );
             return invokeAsync(
                 Authorize.handleResponseEAR,
-                PerformanceEvents.HandleResponseEar,
+                BrowserPerformanceEvents.HandleResponseEar,
                 this.logger,
                 this.performanceClient,
                 request.correlationId
@@ -621,14 +637,14 @@ export class RedirectClient extends StandardInteractionClient {
 
         const authClient = await invokeAsync(
             this.createAuthCodeClient.bind(this),
-            PerformanceEvents.StandardInteractionClientCreateAuthCodeClient,
+            BrowserPerformanceEvents.StandardInteractionClientCreateAuthCodeClient,
             this.logger,
             this.performanceClient,
             this.correlationId
         )({ serverTelemetryManager, requestAuthority: request.authority });
         return invokeAsync(
             Authorize.handleResponseCode,
-            PerformanceEvents.HandleResponseCode,
+            BrowserPerformanceEvents.HandleResponseCode,
             this.logger,
             this.performanceClient,
             request.correlationId
@@ -653,15 +669,16 @@ export class RedirectClient extends StandardInteractionClient {
      * @param urlNavigate
      * @param onRedirectNavigateRequest - onRedirectNavigate callback provided on the request
      */
-    async initiateAuthRequest(
-        requestUrl: string,
-        onRedirectNavigateRequest?: (url: string) => boolean | void
-    ): Promise<void> {
-        this.logger.verbose("RedirectHandler.initiateAuthRequest called");
+    async initiateAuthRequest(requestUrl: string): Promise<void> {
+        this.logger.verbose(
+            "RedirectHandler.initiateAuthRequest called",
+            this.correlationId
+        );
         // Navigate if valid URL
         if (requestUrl) {
             this.logger.infoPii(
-                `RedirectHandler.initiateAuthRequest: Navigate to: ${requestUrl}`
+                `RedirectHandler.initiateAuthRequest: Navigate to: '${requestUrl}'`,
+                this.correlationId
             );
             const navigationOptions: NavigationOptions = {
                 apiId: ApiId.acquireTokenRedirect,
@@ -669,21 +686,21 @@ export class RedirectClient extends StandardInteractionClient {
                 noHistory: false,
             };
 
-            const onRedirectNavigate =
-                onRedirectNavigateRequest ||
-                this.config.auth.onRedirectNavigate;
+            const onRedirectNavigate = this.config.auth.onRedirectNavigate;
 
             // If onRedirectNavigate is implemented, invoke it and provide requestUrl
             if (typeof onRedirectNavigate === "function") {
                 this.logger.verbose(
-                    "RedirectHandler.initiateAuthRequest: Invoking onRedirectNavigate callback"
+                    "RedirectHandler.initiateAuthRequest: Invoking onRedirectNavigate callback",
+                    this.correlationId
                 );
                 const navigate = onRedirectNavigate(requestUrl);
 
                 // Returning false from onRedirectNavigate will stop navigation
                 if (navigate !== false) {
                     this.logger.verbose(
-                        "RedirectHandler.initiateAuthRequest: onRedirectNavigate did not return false, navigating"
+                        "RedirectHandler.initiateAuthRequest: onRedirectNavigate did not return false, navigating",
+                        this.correlationId
                     );
                     await this.navigationClient.navigateExternal(
                         requestUrl,
@@ -692,14 +709,16 @@ export class RedirectClient extends StandardInteractionClient {
                     return;
                 } else {
                     this.logger.verbose(
-                        "RedirectHandler.initiateAuthRequest: onRedirectNavigate returned false, stopping navigation"
+                        "RedirectHandler.initiateAuthRequest: onRedirectNavigate returned false, stopping navigation",
+                        this.correlationId
                     );
                     return;
                 }
             } else {
                 // Navigate window to request URL
                 this.logger.verbose(
-                    "RedirectHandler.initiateAuthRequest: Navigating window to navigate url"
+                    "RedirectHandler.initiateAuthRequest: Navigating window to navigate url",
+                    this.correlationId
                 );
                 await this.navigationClient.navigateExternal(
                     requestUrl,
@@ -710,7 +729,8 @@ export class RedirectClient extends StandardInteractionClient {
         } else {
             // Throw error if request URL is empty.
             this.logger.info(
-                "RedirectHandler.initiateAuthRequest: Navigate url is empty"
+                "RedirectHandler.initiateAuthRequest: Navigate url is empty",
+                this.correlationId
             );
             throw createBrowserAuthError(
                 BrowserAuthErrorCodes.emptyNavigateUri
@@ -724,10 +744,14 @@ export class RedirectClient extends StandardInteractionClient {
      * @param logoutRequest
      */
     async logout(logoutRequest?: EndSessionRequest): Promise<void> {
-        this.logger.verbose("logoutRedirect called");
+        this.logger.verbose("logoutRedirect called", this.correlationId);
         const validLogoutRequest = this.initializeLogoutRequest(logoutRequest);
-        const serverTelemetryManager = this.initializeServerTelemetryManager(
-            ApiId.logout
+        const serverTelemetryManager = initializeServerTelemetryManager(
+            ApiId.logout,
+            this.config.auth.clientId,
+            this.correlationId,
+            this.browserStorage,
+            this.logger
         );
 
         try {
@@ -738,7 +762,10 @@ export class RedirectClient extends StandardInteractionClient {
             );
 
             // Clear cache on logout
-            await this.clearCacheOnLogout(
+            await clearCacheOnLogout(
+                this.browserStorage,
+                this.browserCrypto,
+                this.logger,
                 this.correlationId,
                 validLogoutRequest.account
             );
@@ -751,7 +778,7 @@ export class RedirectClient extends StandardInteractionClient {
 
             const authClient = await invokeAsync(
                 this.createAuthCodeClient.bind(this),
-                PerformanceEvents.StandardInteractionClientCreateAuthCodeClient,
+                BrowserPerformanceEvents.StandardInteractionClientCreateAuthCodeClient,
                 this.logger,
                 this.performanceClient,
                 this.correlationId
@@ -763,17 +790,36 @@ export class RedirectClient extends StandardInteractionClient {
                 account: (logoutRequest && logoutRequest.account) || undefined,
             });
 
+            // Create a serializable version of the request for events
+            const {
+                // @ts-ignore
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                onRedirectNavigate,
+                ...serializableLogoutRequest
+            } = validLogoutRequest;
+
             if (authClient.authority.protocolMode === ProtocolMode.OIDC) {
                 try {
                     authClient.authority.endSessionEndpoint;
                 } catch {
                     if (validLogoutRequest.account?.homeAccountId) {
-                        this.eventHandler.emitEvent(
-                            EventType.LOGOUT_SUCCESS,
-                            InteractionType.Redirect,
-                            validLogoutRequest
-                        );
-
+                        if (
+                            // @ts-ignore
+                            typeof validLogoutRequest.onRedirectNavigate ===
+                            "function"
+                        ) {
+                            this.eventHandler.emitEvent(
+                                EventType.LOGOUT_SUCCESS,
+                                InteractionType.Redirect,
+                                serializableLogoutRequest
+                            );
+                        } else {
+                            this.eventHandler.emitEvent(
+                                EventType.LOGOUT_SUCCESS,
+                                InteractionType.Redirect,
+                                validLogoutRequest
+                            );
+                        }
                         return;
                     }
                 }
@@ -783,11 +829,24 @@ export class RedirectClient extends StandardInteractionClient {
             const logoutUri: string =
                 authClient.getLogoutUri(validLogoutRequest);
 
-            this.eventHandler.emitEvent(
-                EventType.LOGOUT_SUCCESS,
-                InteractionType.Redirect,
-                validLogoutRequest
-            );
+            if (validLogoutRequest.account?.homeAccountId) {
+                if (
+                    // @ts-ignore
+                    typeof validLogoutRequest.onRedirectNavigate === "function"
+                ) {
+                    this.eventHandler.emitEvent(
+                        EventType.LOGOUT_SUCCESS,
+                        InteractionType.Redirect,
+                        serializableLogoutRequest
+                    );
+                } else {
+                    this.eventHandler.emitEvent(
+                        EventType.LOGOUT_SUCCESS,
+                        InteractionType.Redirect,
+                        validLogoutRequest
+                    );
+                }
+            }
             // Check if onRedirectNavigate is implemented, and invoke it if so
             if (
                 logoutRequest &&
@@ -797,7 +856,8 @@ export class RedirectClient extends StandardInteractionClient {
 
                 if (navigate !== false) {
                     this.logger.verbose(
-                        "Logout onRedirectNavigate did not return false, navigating"
+                        "Logout onRedirectNavigate did not return false, navigating",
+                        this.correlationId
                     );
                     // Ensure interaction is in progress
                     if (!this.browserStorage.getInteractionInProgress()) {
@@ -815,7 +875,8 @@ export class RedirectClient extends StandardInteractionClient {
                     // Ensure interaction is not in progress
                     this.browserStorage.setInteractionInProgress(false);
                     this.logger.verbose(
-                        "Logout onRedirectNavigate returned false, stopping navigation"
+                        "Logout onRedirectNavigate returned false, stopping navigation",
+                        this.correlationId
                     );
                 }
             } else {