@azure/msal-browser 4.27.0 → 5.0.0-beta.0

package/src/broker/nativeBroker/PlatformAuthDOMHandler.ts

@@ -45,7 +45,10 @@ export class PlatformAuthDOMHandler implements IPlatformAuthHandler {
         performanceClient: IPerformanceClient,
         correlationId: string
     ): Promise<PlatformAuthDOMHandler | undefined> {
-        logger.trace("PlatformAuthDOMHandler: createProvider called");
+        logger.trace(
+            "PlatformAuthDOMHandler: createProvider called",
+            correlationId
+        );
 
         // @ts-ignore
         if (window.navigator?.platformAuthentication) {
@@ -59,7 +62,10 @@ export class PlatformAuthDOMHandler implements IPlatformAuthHandler {
                     PlatformAuthConstants.PLATFORM_DOM_APIS
                 )
             ) {
-                logger.trace("Platform auth api available in DOM");
+                logger.trace(
+                    "Platform auth api available in DOM",
+                    correlationId
+                );
                 return new PlatformAuthDOMHandler(
                     logger,
                     performanceClient,
@@ -95,7 +101,8 @@ export class PlatformAuthDOMHandler implements IPlatformAuthHandler {
         request: PlatformAuthRequest
     ): Promise<PlatformAuthResponse> {
         this.logger.trace(
-            this.platformAuthType + " - Sending request to browser DOM API"
+            `'${this.platformAuthType}' - Sending request to browser DOM API`,
+            request.correlationId
         );
 
         try {
@@ -106,10 +113,14 @@ export class PlatformAuthDOMHandler implements IPlatformAuthHandler {
                 await window.navigator.platformAuthentication.executeGetToken(
                     platformDOMRequest
                 );
-            return this.validatePlatformBrokerResponse(response);
+            return this.validatePlatformBrokerResponse(
+                response,
+                request.correlationId
+            );
         } catch (e) {
             this.logger.error(
-                this.platformAuthType + " - executeGetToken DOM API error"
+                `'${this.platformAuthType}' - executeGetToken DOM API error`,
+                request.correlationId
             );
             throw e;
         }
@@ -119,7 +130,8 @@ export class PlatformAuthDOMHandler implements IPlatformAuthHandler {
         request: PlatformAuthRequest
     ): PlatformDOMTokenRequest {
         this.logger.trace(
-            this.platformAuthType + " - initializeNativeDOMRequest called"
+            `'${this.platformAuthType}' - initializeNativeDOMRequest called`,
+            request.correlationId
         );
 
         const {
@@ -158,7 +170,8 @@ export class PlatformAuthDOMHandler implements IPlatformAuthHandler {
     }
 
     private validatePlatformBrokerResponse(
-        response: object
+        response: object,
+        correlationId: string
     ): PlatformAuthResponse {
         if (response.hasOwnProperty("isSuccess")) {
             if (
@@ -170,11 +183,12 @@ export class PlatformAuthDOMHandler implements IPlatformAuthHandler {
                 response.hasOwnProperty("expiresIn")
             ) {
                 this.logger.trace(
-                    this.platformAuthType +
-                        " - platform broker returned successful and valid response"
+                    `'${this.platformAuthType}' - platform broker returned successful and valid response`,
+                    correlationId
                 );
                 return this.convertToPlatformBrokerResponse(
-                    response as PlatformDOMTokenResponse
+                    response as PlatformDOMTokenResponse,
+                    correlationId
                 );
             } else if (response.hasOwnProperty("error")) {
                 const errorResponse = response as PlatformDOMTokenResponse;
@@ -184,8 +198,8 @@ export class PlatformAuthDOMHandler implements IPlatformAuthHandler {
                     errorResponse.error.code
                 ) {
                     this.logger.trace(
-                        this.platformAuthType +
-                            " - platform broker returned error response"
+                        `'${this.platformAuthType}' - platform broker returned error response`,
+                        correlationId
                     );
                     throw createNativeAuthError(
                         errorResponse.error.code,
@@ -207,10 +221,12 @@ export class PlatformAuthDOMHandler implements IPlatformAuthHandler {
     }
 
     private convertToPlatformBrokerResponse(
-        response: PlatformDOMTokenResponse
+        response: PlatformDOMTokenResponse,
+        correlationId: string
     ): PlatformAuthResponse {
         this.logger.trace(
-            this.platformAuthType + " - convertToNativeResponse called"
+            `'${this.platformAuthType}' - convertToNativeResponse called`,
+            correlationId
         );
         const nativeResponse: PlatformAuthResponse = {
             access_token: response.accessToken,

package/src/broker/nativeBroker/PlatformAuthExtensionHandler.ts

@@ -13,9 +13,9 @@ import {
     createAuthError,
     AuthErrorCodes,
     InProgressPerformanceEvent,
-    PerformanceEvents,
     IPerformanceClient,
 } from "@azure/msal-common/browser";
+import * as BrowserPerformanceEvents from "../../telemetry/BrowserPerformanceEvents.js";
 import {
     NativeExtensionRequest,
     NativeExtensionRequestBody,
@@ -29,6 +29,7 @@ import {
 import { createNewGuid } from "../../crypto/BrowserCrypto.js";
 import { PlatformAuthResponse } from "./PlatformAuthResponse.js";
 import { IPlatformAuthHandler } from "./IPlatformAuthHandler.js";
+import { createGuid } from "../../utils/BrowserUtils.js";
 
 type ResponseResolvers<T> = {
     resolve: (value: T | PromiseLike<T>) => void;
@@ -66,7 +67,7 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
         this.windowListener = this.onWindowMessage.bind(this); // Window event callback doesn't have access to 'this' unless it's bound
         this.performanceClient = performanceClient;
         this.handshakeEvent = performanceClient.startMeasurement(
-            PerformanceEvents.NativeMessageHandlerHandshake
+            BrowserPerformanceEvents.NativeMessageHandlerHandshake
         );
         this.platformAuthType =
             PlatformAuthConstants.PLATFORM_EXTENSION_PROVIDER;
@@ -79,7 +80,10 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
     async sendMessage(
         request: PlatformAuthRequest
     ): Promise<PlatformAuthResponse> {
-        this.logger.trace(this.platformAuthType + " - sendMessage called.");
+        this.logger.trace(
+            `'${this.platformAuthType}' - sendMessage called.`,
+            request.correlationId
+        );
 
         // fall back to native calls
         const messageBody: NativeExtensionRequestBody = {
@@ -95,13 +99,16 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
         };
 
         this.logger.trace(
-            this.platformAuthType + " - Sending request to browser extension"
+            `'${this.platformAuthType}' - Sending request to browser extension`,
+            request.correlationId
         );
         this.logger.tracePii(
-            this.platformAuthType +
-                ` - Sending request to browser extension: ${JSON.stringify(
-                    req
-                )}`
+            `'${
+                this.platformAuthType
+            }' - Sending request to browser extension: '${JSON.stringify(
+                req
+            )}'`,
+            request.correlationId
         );
         this.messageChannel.port1.postMessage(req);
 
@@ -125,9 +132,13 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
     static async createProvider(
         logger: Logger,
         handshakeTimeoutMs: number,
-        performanceClient: IPerformanceClient
+        performanceClient: IPerformanceClient,
+        correlationId: string
     ): Promise<PlatformAuthExtensionHandler> {
-        logger.trace("PlatformAuthExtensionHandler - createProvider called.");
+        logger.trace(
+            "PlatformAuthExtensionHandler - createProvider called.",
+            correlationId
+        );
 
         try {
             const preferredProvider = new PlatformAuthExtensionHandler(
@@ -136,7 +147,7 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
                 performanceClient,
                 PlatformAuthConstants.PREFERRED_EXTENSION_ID
             );
-            await preferredProvider.sendHandshakeRequest();
+            await preferredProvider.sendHandshakeRequest(correlationId);
             return preferredProvider;
         } catch (e) {
             // If preferred extension fails for whatever reason, fallback to using any installed extension
@@ -145,7 +156,7 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
                 handshakeTimeoutMs,
                 performanceClient
             );
-            await backupProvider.sendHandshakeRequest();
+            await backupProvider.sendHandshakeRequest(correlationId);
             return backupProvider;
         }
     }
@@ -153,9 +164,10 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
     /**
      * Send handshake request helper.
      */
-    private async sendHandshakeRequest(): Promise<void> {
+    private async sendHandshakeRequest(correlationId: string): Promise<void> {
         this.logger.trace(
-            this.platformAuthType + " - sendHandshakeRequest called."
+            `'${this.platformAuthType}' - sendHandshakeRequest called.`,
+            correlationId
         );
         // Register this event listener before sending handshake
         window.addEventListener("message", this.windowListener, false); // false is important, because content script message processing should work first
@@ -212,7 +224,11 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
      * @param event
      */
     private onWindowMessage(event: MessageEvent): void {
-        this.logger.trace(this.platformAuthType + " - onWindowMessage called");
+        const correlationId = createGuid();
+        this.logger.trace(
+            `'${this.platformAuthType}' - onWindowMessage called`,
+            correlationId
+        );
         // We only accept messages from ourselves
         if (event.source !== window) {
             return;
@@ -241,8 +257,8 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
              */
             if (!handshakeResolver) {
                 this.logger.trace(
-                    this.platformAuthType +
-                        `.onWindowMessage - resolver can't be found for request ${request.responseId}`
+                    `'${this.platformAuthType}'.onWindowMessage - resolver can't be found for request '${request.responseId}'`,
+                    correlationId
                 );
                 return;
             }
@@ -251,7 +267,8 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
             this.logger.verbose(
                 request.extensionId
                     ? `Extension with id: ${request.extensionId} not installed`
-                    : "No extension installed"
+                    : "No extension installed",
+                correlationId
             );
             clearTimeout(this.timeoutId);
             this.messageChannel.port1.close();
@@ -274,8 +291,10 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
      * @param event
      */
     private onChannelMessage(event: MessageEvent): void {
+        const correlationId = createGuid();
         this.logger.trace(
-            this.platformAuthType + " - onChannelMessage called."
+            `'${this.platformAuthType}' - onChannelMessage called.`,
+            correlationId
         );
         const request = event.data;
 
@@ -293,14 +312,16 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
                 }
                 const response = request.body.response;
                 this.logger.trace(
-                    this.platformAuthType +
-                        " - Received response from browser extension"
+                    `'${this.platformAuthType}' - Received response from browser extension`,
+                    correlationId
                 );
                 this.logger.tracePii(
-                    this.platformAuthType +
-                        ` - Received response from browser extension: ${JSON.stringify(
-                            response
-                        )}`
+                    `'${
+                        this.platformAuthType
+                    }' - Received response from browser extension: '${JSON.stringify(
+                        response
+                    )}'`,
+                    correlationId
                 );
                 if (response.status !== "Success") {
                     resolver.reject(
@@ -335,8 +356,8 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
             } else if (method === NativeExtensionMethod.HandshakeResponse) {
                 if (!handshakeResolver) {
                     this.logger.trace(
-                        this.platformAuthType +
-                            `.onChannelMessage - resolver can't be found for request ${request.responseId}`
+                        `'${this.platformAuthType}'.onChannelMessage - resolver can't be found for request '${request.responseId}'`,
+                        correlationId
                     );
                     return;
                 }
@@ -349,8 +370,8 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
                 this.extensionId = request.extensionId;
                 this.extensionVersion = request.body.version;
                 this.logger.verbose(
-                    this.platformAuthType +
-                        ` - Received HandshakeResponse from extension: ${this.extensionId}`
+                    `'${this.platformAuthType}' - Received HandshakeResponse from extension: '${this.extensionId}'`,
+                    correlationId
                 );
                 this.handshakeEvent.end({
                     extensionInstalled: true,
@@ -362,11 +383,15 @@ export class PlatformAuthExtensionHandler implements IPlatformAuthHandler {
             }
             // Do nothing if method is not Response or HandshakeResponse
         } catch (err) {
-            this.logger.error("Error parsing response from WAM Extension");
+            this.logger.error(
+                "Error parsing response from WAM Extension",
+                correlationId
+            );
             this.logger.errorPii(
-                `Error parsing response from WAM Extension: ${err as string}`
+                `Error parsing response from WAM Extension: '${err as string}'`,
+                correlationId
             );
-            this.logger.errorPii(`Unable to parse ${event}`);
+            this.logger.errorPii(`Unable to parse '${event}'`, correlationId);
 
             if (resolver) {
                 resolver.reject(err as AuthError);

package/src/broker/nativeBroker/PlatformAuthProvider.ts

@@ -7,10 +7,8 @@ import {
     LoggerOptions,
     IPerformanceClient,
     Logger,
-    AuthenticationScheme,
+    Constants,
     StubPerformanceClient,
-    createClientConfigurationError,
-    ClientConfigurationErrorCodes,
 } from "@azure/msal-common/browser";
 import { name, version } from "../../packageMetadata.js";
 import {
@@ -20,54 +18,50 @@ import {
 import { PlatformAuthExtensionHandler } from "./PlatformAuthExtensionHandler.js";
 import { IPlatformAuthHandler } from "./IPlatformAuthHandler.js";
 import { PlatformAuthDOMHandler } from "./PlatformAuthDOMHandler.js";
-import { createNewGuid } from "../../crypto/BrowserCrypto.js";
+import { BrowserCacheLocation } from "../../utils/BrowserConstants.js";
+import { PLATFORM_AUTH_DOM_SUPPORT } from "../../cache/CacheKeys.js";
 
 /**
  * Checks if the platform broker is available in the current environment.
  * @param loggerOptions
  * @param perfClient
+ * @param correlationId
  * @returns
  */
 export async function isPlatformBrokerAvailable(
     loggerOptions?: LoggerOptions,
     perfClient?: IPerformanceClient,
-    correlationId?: string,
-    domConfig?: boolean
+    correlationId?: string
 ): Promise<boolean> {
     const logger = new Logger(loggerOptions || {}, name, version);
+    const cid = correlationId || "";
 
-    logger.trace("isPlatformBrokerAvailable called");
+    logger.trace("isPlatformBrokerAvailable called", cid);
 
     const performanceClient = perfClient || new StubPerformanceClient();
 
     if (typeof window === "undefined") {
-        logger.trace("Non-browser environment detected, returning false");
+        logger.trace("Non-browser environment detected, returning false", cid);
         return false;
     }
 
-    return !!(await getPlatformAuthProvider(
-        logger,
-        performanceClient,
-        correlationId || createNewGuid(),
-        undefined,
-        domConfig
-    ));
+    return !!(await getPlatformAuthProvider(logger, performanceClient, cid));
 }
 
 export async function getPlatformAuthProvider(
     logger: Logger,
     performanceClient: IPerformanceClient,
     correlationId: string,
-    nativeBrokerHandshakeTimeout?: number,
-    enablePlatformBrokerDOMSupport?: boolean
+    nativeBrokerHandshakeTimeout?: number
 ): Promise<IPlatformAuthHandler | undefined> {
     logger.trace("getPlatformAuthProvider called", correlationId);
 
+    const enablePlatformBrokerDOMSupport = isDomEnabledForPlatformAuth();
+
     logger.trace(
-        "Has client allowed platform auth via DOM API: " +
-            enablePlatformBrokerDOMSupport
+        `Has client allowed platform auth via DOM API: '${enablePlatformBrokerDOMSupport}'`,
+        correlationId
     );
-
     let platformAuthProvider: IPlatformAuthHandler | undefined;
     try {
         if (enablePlatformBrokerDOMSupport) {
@@ -80,7 +74,8 @@ export async function getPlatformAuthProvider(
         }
         if (!platformAuthProvider) {
             logger.trace(
-                "Platform auth via DOM API not available, checking for extension"
+                "Platform auth via DOM API not available, checking for extension",
+                correlationId
             );
             /*
              * If DOM APIs are not available, check if browser extension is available.
@@ -91,7 +86,8 @@ export async function getPlatformAuthProvider(
                     logger,
                     nativeBrokerHandshakeTimeout ||
                         DEFAULT_NATIVE_BROKER_HANDSHAKE_TIMEOUT_MS,
-                    performanceClient
+                    performanceClient,
+                    correlationId
                 );
         }
     } catch (e) {
@@ -100,34 +96,42 @@ export async function getPlatformAuthProvider(
     return platformAuthProvider;
 }
 
+/**
+ * Returns true if the DOM API support for platform auth is enabled in session storage
+ * @returns boolean
+ * @deprecated
+ */
+export function isDomEnabledForPlatformAuth(): boolean {
+    let sessionStorage: Storage | undefined;
+    try {
+        sessionStorage = window[BrowserCacheLocation.SessionStorage];
+        // Mute errors if it's a non-browser environment or cookies are blocked.
+        return sessionStorage?.getItem(PLATFORM_AUTH_DOM_SUPPORT) === "true";
+    } catch (e) {
+        return false;
+    }
+}
+
 /**
  * Returns boolean indicating whether or not the request should attempt to use native broker
  * @param logger
  * @param config
+ * @param correlationId
  * @param platformAuthProvider
  * @param authenticationScheme
  */
 export function isPlatformAuthAllowed(
     config: BrowserConfiguration,
     logger: Logger,
+    correlationId: string,
     platformAuthProvider?: IPlatformAuthHandler,
-    authenticationScheme?: AuthenticationScheme
+    authenticationScheme?: Constants.AuthenticationScheme
 ): boolean {
-    logger.trace("isPlatformAuthAllowed called");
-
-    // throw an error if allowPlatformBroker is not enabled and allowPlatformBrokerWithDOM is enabled
-    if (
-        !config.system.allowPlatformBroker &&
-        config.system.allowPlatformBrokerWithDOM
-    ) {
-        throw createClientConfigurationError(
-            ClientConfigurationErrorCodes.invalidPlatformBrokerConfiguration
-        );
-    }
-
+    logger.trace("isPlatformAuthAllowed called", correlationId);
     if (!config.system.allowPlatformBroker) {
         logger.trace(
-            "isPlatformAuthAllowed: allowPlatformBroker is not enabled, returning false"
+            "isPlatformAuthAllowed: allowPlatformBroker is not enabled, returning false",
+            correlationId
         );
         // Developer disabled WAM
         return false;
@@ -135,7 +139,8 @@ export function isPlatformAuthAllowed(
 
     if (!platformAuthProvider) {
         logger.trace(
-            "isPlatformAuthAllowed: Platform auth provider is not initialized, returning false"
+            "isPlatformAuthAllowed: Platform auth provider is not initialized, returning false",
+            correlationId
         );
         // Platform broker auth providers are not available
         return false;
@@ -143,15 +148,17 @@ export function isPlatformAuthAllowed(
 
     if (authenticationScheme) {
         switch (authenticationScheme) {
-            case AuthenticationScheme.BEARER:
-            case AuthenticationScheme.POP:
+            case Constants.AuthenticationScheme.BEARER:
+            case Constants.AuthenticationScheme.POP:
                 logger.trace(
-                    "isPlatformAuthAllowed: authenticationScheme is supported, returning true"
+                    "isPlatformAuthAllowed: authenticationScheme is supported, returning true",
+                    correlationId
                 );
                 return true;
             default:
                 logger.trace(
-                    "isPlatformAuthAllowed: authenticationScheme is not supported, returning false"
+                    "isPlatformAuthAllowed: authenticationScheme is not supported, returning false",
+                    correlationId
                 );
                 return false;
         }

package/src/cache/AccountManager.ts

@@ -18,9 +18,9 @@ export function getAllAccounts(
     correlationId: string,
     accountFilter?: AccountFilter
 ): AccountInfo[] {
-    logger.verbose("getAllAccounts called");
+    logger.verbose("getAllAccounts called", correlationId);
     return isInBrowser
-        ? browserStorage.getAllAccounts(accountFilter || {}, correlationId)
+        ? browserStorage.getAllAccounts(accountFilter, correlationId)
         : [];
 }
 
@@ -35,141 +35,27 @@ export function getAccount(
     browserStorage: BrowserCacheManager,
     correlationId: string
 ): AccountInfo | null {
-    const account: AccountInfo | null = browserStorage.getAccountInfoFilteredBy(
-        accountFilter,
-        correlationId
-    );
-
-    if (account) {
-        logger.verbose(
-            "getAccount: Account matching provided filter found, returning"
-        );
-        return account;
-    } else {
-        logger.verbose("getAccount: No matching account found, returning null");
-        return null;
-    }
-}
-
-/**
- * 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
- */
-export function getAccountByUsername(
-    username: string,
-    logger: Logger,
-    browserStorage: BrowserCacheManager,
-    correlationId: string
-): AccountInfo | null {
-    logger.trace("getAccountByUsername called");
-    if (!username) {
-        logger.warning("getAccountByUsername: No username provided");
-        return null;
-    }
-
-    const account = browserStorage.getAccountInfoFilteredBy(
-        {
-            username,
-        },
-        correlationId
-    );
-    if (account) {
-        logger.verbose(
-            "getAccountByUsername: Account matching username found, returning"
-        );
-        logger.verbosePii(
-            `getAccountByUsername: Returning signed-in accounts matching username: ${username}`
-        );
-        return account;
-    } else {
-        logger.verbose(
-            "getAccountByUsername: No matching account found, returning null"
-        );
-        return null;
-    }
-}
-
-/**
- * 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
- */
-export function getAccountByHomeId(
-    homeAccountId: string,
-    logger: Logger,
-    browserStorage: BrowserCacheManager,
-    correlationId: string
-): AccountInfo | null {
-    logger.trace("getAccountByHomeId called");
-    if (!homeAccountId) {
-        logger.warning("getAccountByHomeId: No homeAccountId provided");
+    logger.trace("getAccount called", correlationId);
+    if (Object.keys(accountFilter).length === 0) {
+        logger.warning("getAccount: No accountFilter provided", correlationId);
         return null;
     }
 
-    const account = browserStorage.getAccountInfoFilteredBy(
-        {
-            homeAccountId,
-        },
+    const account: AccountInfo | null = browserStorage.getAccountInfoFilteredBy(
+        accountFilter,
         correlationId
     );
-    if (account) {
-        logger.verbose(
-            "getAccountByHomeId: Account matching homeAccountId found, returning"
-        );
-        logger.verbosePii(
-            `getAccountByHomeId: Returning signed-in accounts matching homeAccountId: ${homeAccountId}`
-        );
-        return account;
-    } else {
-        logger.verbose(
-            "getAccountByHomeId: No matching account found, returning null"
-        );
-        return null;
-    }
-}
 
-/**
- * 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
- */
-export function getAccountByLocalId(
-    localAccountId: string,
-    logger: Logger,
-    browserStorage: BrowserCacheManager,
-    correlationId: string
-): AccountInfo | null {
-    logger.trace("getAccountByLocalId called");
-    if (!localAccountId) {
-        logger.warning("getAccountByLocalId: No localAccountId provided");
-        return null;
-    }
-
-    const account = browserStorage.getAccountInfoFilteredBy(
-        {
-            localAccountId,
-        },
-        correlationId
-    );
     if (account) {
         logger.verbose(
-            "getAccountByLocalId: Account matching localAccountId found, returning"
-        );
-        logger.verbosePii(
-            `getAccountByLocalId: Returning signed-in accounts matching localAccountId: ${localAccountId}`
+            "getAccount: Account matching provided filter found, returning",
+            correlationId
         );
         return account;
     } else {
         logger.verbose(
-            "getAccountByLocalId: No matching account found, returning null"
+            "getAccount: No matching account found, returning null",
+            correlationId
         );
         return null;
     }