@azure/msal-common 14.16.0 → 14.16.1

package/src/cache/CacheManager.ts

@@ -53,7 +53,8 @@ import { getAliasesFromStaticSources } from "../authority/AuthorityMetadata.js";
 import { StaticAuthorityOptions } from "../authority/AuthorityOptions.js";
 import { TokenClaims } from "../account/TokenClaims.js";
 import { IPerformanceClient } from "../telemetry/performance/IPerformanceClient.js";
-import { CacheError, CacheErrorCodes } from "../error/CacheError.js";
+import { createCacheError } from "../error/CacheError.js";
+import { AuthError } from "../error/AuthError.js";
 
 /**
  * Interface class which implement cache storage functions used by MSAL to perform validity checks, and store tokens.
@@ -84,64 +85,85 @@ export abstract class CacheManager implements ICacheManager {
      */
     abstract getAccount(
         accountKey: string,
+        correlationId: string,
         logger?: Logger
     ): AccountEntity | null;
 
     /**
      * Returns deserialized account if found in the cache, otherwiser returns null
      */
-    abstract getCachedAccountEntity(accountKey: string): AccountEntity | null;
+    abstract getCachedAccountEntity(
+        accountKey: string,
+        correlationId: string
+    ): AccountEntity | null;
 
     /**
      * set account entity in the platform cache
      * @param account
      */
-    abstract setAccount(account: AccountEntity): void;
+    abstract setAccount(account: AccountEntity, correlationId: string): void;
 
     /**
      * remove account entity from the platform cache if it's outdated
      */
-    abstract removeOutdatedAccount(accountKey: string): void;
+    abstract removeOutdatedAccount(
+        accountKey: string,
+        correlationId: string
+    ): void;
 
     /**
      * fetch the idToken entity from the platform cache
      * @param idTokenKey
      */
-    abstract getIdTokenCredential(idTokenKey: string): IdTokenEntity | null;
+    abstract getIdTokenCredential(
+        idTokenKey: string,
+        correlationId: string
+    ): IdTokenEntity | null;
 
     /**
      * set idToken entity to the platform cache
      * @param idToken
      */
-    abstract setIdTokenCredential(idToken: IdTokenEntity): void;
+    abstract setIdTokenCredential(
+        idToken: IdTokenEntity,
+        correlationId: string
+    ): void;
 
     /**
      * fetch the idToken entity from the platform cache
      * @param accessTokenKey
      */
     abstract getAccessTokenCredential(
-        accessTokenKey: string
+        accessTokenKey: string,
+        correlationId: string
     ): AccessTokenEntity | null;
 
     /**
      * set idToken entity to the platform cache
      * @param accessToken
      */
-    abstract setAccessTokenCredential(accessToken: AccessTokenEntity): void;
+    abstract setAccessTokenCredential(
+        accessToken: AccessTokenEntity,
+        correlationId: string
+    ): void;
 
     /**
      * fetch the idToken entity from the platform cache
      * @param refreshTokenKey
      */
     abstract getRefreshTokenCredential(
-        refreshTokenKey: string
+        refreshTokenKey: string,
+        correlationId: string
     ): RefreshTokenEntity | null;
 
     /**
      * set idToken entity to the platform cache
      * @param refreshToken
      */
-    abstract setRefreshTokenCredential(refreshToken: RefreshTokenEntity): void;
+    abstract setRefreshTokenCredential(
+        refreshToken: RefreshTokenEntity,
+        correlationId: string
+    ): void;
 
     /**
      * fetch appMetadata entity from the platform cache
@@ -153,7 +175,10 @@ export abstract class CacheManager implements ICacheManager {
      * set appMetadata entity to the platform cache
      * @param appMetadata
      */
-    abstract setAppMetadata(appMetadata: AppMetadataEntity): void;
+    abstract setAppMetadata(
+        appMetadata: AppMetadataEntity,
+        correlationId: string
+    ): void;
 
     /**
      * fetch server telemetry entity from the platform cache
@@ -170,7 +195,8 @@ export abstract class CacheManager implements ICacheManager {
      */
     abstract setServerTelemetry(
         serverTelemetryKey: string,
-        serverTelemetry: ServerTelemetryEntity
+        serverTelemetry: ServerTelemetryEntity,
+        correlationId: string
     ): void;
 
     /**
@@ -209,14 +235,15 @@ export abstract class CacheManager implements ICacheManager {
      */
     abstract setThrottlingCache(
         throttlingCacheKey: string,
-        throttlingCache: ThrottlingEntity
+        throttlingCache: ThrottlingEntity,
+        correlationId: string
     ): void;
 
     /**
      * Function to remove an item from cache given its key.
      * @param key
      */
-    abstract removeItem(key: string): void;
+    abstract removeItem(key: string, correlationId: string): void;
 
     /**
      * Function which retrieves all current keys from the cache.
@@ -238,7 +265,8 @@ export abstract class CacheManager implements ICacheManager {
      */
     abstract updateCredentialCacheKey(
         currentCacheKey: string,
-        credential: ValidCredentialType
+        credential: ValidCredentialType,
+        correlationId: string
     ): string;
 
     /**
@@ -246,9 +274,13 @@ export abstract class CacheManager implements ICacheManager {
      * @param accountFilter - (Optional) filter to narrow down the accounts returned
      * @returns Array of AccountInfo objects in cache
      */
-    getAllAccounts(accountFilter?: AccountFilter): AccountInfo[] {
+    getAllAccounts(
+        correlationId: string,
+        accountFilter?: AccountFilter
+    ): AccountInfo[] {
         return this.buildTenantProfiles(
-            this.getAccountsFilteredBy(accountFilter || {}),
+            this.getAccountsFilteredBy(accountFilter || {}, correlationId),
+            correlationId,
             accountFilter
         );
     }
@@ -256,8 +288,11 @@ export abstract class CacheManager implements ICacheManager {
     /**
      * Gets first tenanted AccountInfo object found based on provided filters
      */
-    getAccountInfoFilteredBy(accountFilter: AccountFilter): AccountInfo | null {
-        const allAccounts = this.getAllAccounts(accountFilter);
+    getAccountInfoFilteredBy(
+        accountFilter: AccountFilter,
+        correlationId: string
+    ): AccountInfo | null {
+        const allAccounts = this.getAllAccounts(correlationId, accountFilter);
         if (allAccounts.length > 1) {
             // If one or more accounts are found, prioritize accounts that have an ID token
             const sortedAccounts = allAccounts.sort((account) => {
@@ -277,8 +312,14 @@ export abstract class CacheManager implements ICacheManager {
      * @param accountFilter
      * @returns
      */
-    getBaseAccountInfo(accountFilter: AccountFilter): AccountInfo | null {
-        const accountEntities = this.getAccountsFilteredBy(accountFilter);
+    getBaseAccountInfo(
+        accountFilter: AccountFilter,
+        correlationId: string
+    ): AccountInfo | null {
+        const accountEntities = this.getAccountsFilteredBy(
+            accountFilter,
+            correlationId
+        );
         if (accountEntities.length > 0) {
             return accountEntities[0].getAccountInfo();
         } else {
@@ -295,11 +336,13 @@ export abstract class CacheManager implements ICacheManager {
      */
     private buildTenantProfiles(
         cachedAccounts: AccountEntity[],
+        correlationId: string,
         accountFilter?: AccountFilter
     ): AccountInfo[] {
         return cachedAccounts.flatMap((accountEntity) => {
             return this.getTenantProfilesFromAccountEntity(
                 accountEntity,
+                correlationId,
                 accountFilter?.tenantId,
                 accountFilter
             );
@@ -310,6 +353,7 @@ export abstract class CacheManager implements ICacheManager {
         accountInfo: AccountInfo,
         tokenKeys: TokenKeys,
         tenantProfile: TenantProfile,
+        correlationId: string,
         tenantProfileFilter?: TenantProfileFilter
     ): AccountInfo | null {
         let tenantedAccountInfo: AccountInfo | null = null;
@@ -328,6 +372,7 @@ export abstract class CacheManager implements ICacheManager {
 
         const idToken = this.getIdToken(
             accountInfo,
+            correlationId,
             tokenKeys,
             tenantProfile.tenantId
         );
@@ -362,6 +407,7 @@ export abstract class CacheManager implements ICacheManager {
 
     private getTenantProfilesFromAccountEntity(
         accountEntity: AccountEntity,
+        correlationId: string,
         targetTenantId?: string,
         tenantProfileFilter?: TenantProfileFilter
     ): AccountInfo[] {
@@ -390,6 +436,7 @@ export abstract class CacheManager implements ICacheManager {
                 accountInfo,
                 tokenKeys,
                 tenantProfile,
+                correlationId,
                 tenantProfileFilter
             );
             if (tenantedAccountInfo) {
@@ -493,8 +540,8 @@ export abstract class CacheManager implements ICacheManager {
      */
     async saveCacheRecord(
         cacheRecord: CacheRecord,
-        storeInCache?: StoreInCache,
-        correlationId?: string
+        correlationId: string,
+        storeInCache?: StoreInCache
     ): Promise<void> {
         if (!cacheRecord) {
             throw createClientAuthError(
@@ -504,59 +551,42 @@ export abstract class CacheManager implements ICacheManager {
 
         try {
             if (!!cacheRecord.account) {
-                this.setAccount(cacheRecord.account);
+                this.setAccount(cacheRecord.account, correlationId);
             }
 
             if (!!cacheRecord.idToken && storeInCache?.idToken !== false) {
-                this.setIdTokenCredential(cacheRecord.idToken);
+                this.setIdTokenCredential(cacheRecord.idToken, correlationId);
             }
 
             if (
                 !!cacheRecord.accessToken &&
                 storeInCache?.accessToken !== false
             ) {
-                await this.saveAccessToken(cacheRecord.accessToken);
+                await this.saveAccessToken(
+                    cacheRecord.accessToken,
+                    correlationId
+                );
             }
 
             if (
                 !!cacheRecord.refreshToken &&
                 storeInCache?.refreshToken !== false
             ) {
-                this.setRefreshTokenCredential(cacheRecord.refreshToken);
+                this.setRefreshTokenCredential(
+                    cacheRecord.refreshToken,
+                    correlationId
+                );
             }
 
             if (!!cacheRecord.appMetadata) {
-                this.setAppMetadata(cacheRecord.appMetadata);
+                this.setAppMetadata(cacheRecord.appMetadata, correlationId);
             }
         } catch (e: unknown) {
             this.commonLogger?.error(`CacheManager.saveCacheRecord: failed`);
-            if (e instanceof Error) {
-                this.commonLogger?.errorPii(
-                    `CacheManager.saveCacheRecord: ${e.message}`,
-                    correlationId
-                );
-
-                if (
-                    e.name === "QuotaExceededError" ||
-                    e.name === "NS_ERROR_DOM_QUOTA_REACHED" ||
-                    e.message.includes("exceeded the quota")
-                ) {
-                    this.commonLogger?.error(
-                        `CacheManager.saveCacheRecord: exceeded storage quota`,
-                        correlationId
-                    );
-                    throw new CacheError(
-                        CacheErrorCodes.cacheQuotaExceededErrorCode
-                    );
-                } else {
-                    throw new CacheError(e.name, e.message);
-                }
+            if (e instanceof AuthError) {
+                throw e;
             } else {
-                this.commonLogger?.errorPii(
-                    `CacheManager.saveCacheRecord: ${e}`,
-                    correlationId
-                );
-                throw new CacheError(CacheErrorCodes.cacheUnknownErrorCode);
+                throw createCacheError(e);
             }
         }
     }
@@ -566,7 +596,8 @@ export abstract class CacheManager implements ICacheManager {
      * @param credential
      */
     private async saveAccessToken(
-        credential: AccessTokenEntity
+        credential: AccessTokenEntity,
+        correlationId: string
     ): Promise<void> {
         const accessTokenFilter: CredentialFilter = {
             clientId: credential.clientId,
@@ -581,7 +612,6 @@ export abstract class CacheManager implements ICacheManager {
         const tokenKeys = this.getTokenKeys();
         const currentScopes = ScopeSet.fromString(credential.target);
 
-        const removedAccessTokens: Array<Promise<void>> = [];
         tokenKeys.accessToken.forEach((key) => {
             if (
                 !this.accessTokenKeyMatchesFilter(key, accessTokenFilter, false)
@@ -589,7 +619,10 @@ export abstract class CacheManager implements ICacheManager {
                 return;
             }
 
-            const tokenEntity = this.getAccessTokenCredential(key);
+            const tokenEntity = this.getAccessTokenCredential(
+                key,
+                correlationId
+            );
 
             if (
                 tokenEntity &&
@@ -597,12 +630,11 @@ export abstract class CacheManager implements ICacheManager {
             ) {
                 const tokenScopeSet = ScopeSet.fromString(tokenEntity.target);
                 if (tokenScopeSet.intersectingScopeSets(currentScopes)) {
-                    removedAccessTokens.push(this.removeAccessToken(key));
+                    this.removeAccessToken(key, correlationId);
                 }
             }
         });
-        await Promise.all(removedAccessTokens);
-        this.setAccessTokenCredential(credential);
+        this.setAccessTokenCredential(credential, correlationId);
     }
 
     /**
@@ -610,7 +642,10 @@ export abstract class CacheManager implements ICacheManager {
      * Not checking for casing as keys are all generated in lower case, remember to convert to lower case if object properties are compared
      * @param accountFilter - An object containing Account properties to filter by
      */
-    getAccountsFilteredBy(accountFilter: AccountFilter): AccountEntity[] {
+    getAccountsFilteredBy(
+        accountFilter: AccountFilter,
+        correlationId: string
+    ): AccountEntity[] {
         const allAccountKeys = this.getAccountKeys();
         const matchingAccounts: AccountEntity[] = [];
         allAccountKeys.forEach((cacheKey) => {
@@ -621,6 +656,7 @@ export abstract class CacheManager implements ICacheManager {
 
             const entity: AccountEntity | null = this.getAccount(
                 cacheKey,
+                correlationId,
                 this.commonLogger
             );
 
@@ -952,12 +988,12 @@ export abstract class CacheManager implements ICacheManager {
     /**
      * Removes all accounts and related tokens from cache.
      */
-    async removeAllAccounts(): Promise<void> {
+    async removeAllAccounts(correlationId: string): Promise<void> {
         const allAccountKeys = this.getAccountKeys();
         const removedAccounts: Array<Promise<void>> = [];
 
         allAccountKeys.forEach((cacheKey) => {
-            removedAccounts.push(this.removeAccount(cacheKey));
+            removedAccounts.push(this.removeAccount(cacheKey, correlationId));
         });
 
         await Promise.all(removedAccounts);
@@ -967,43 +1003,56 @@ export abstract class CacheManager implements ICacheManager {
      * Removes the account and related tokens for a given account key
      * @param account
      */
-    async removeAccount(accountKey: string): Promise<void> {
-        const account = this.getAccount(accountKey, this.commonLogger);
+    async removeAccount(
+        accountKey: string,
+        correlationId: string
+    ): Promise<void> {
+        const account = this.getAccount(
+            accountKey,
+            correlationId,
+            this.commonLogger
+        );
         if (!account) {
             return;
         }
-        await this.removeAccountContext(account);
-        this.removeItem(accountKey);
+        await this.removeAccountContext(account, correlationId);
+        this.removeItem(accountKey, correlationId);
     }
 
     /**
      * Removes credentials associated with the provided account
      * @param account
      */
-    async removeAccountContext(account: AccountEntity): Promise<void> {
+    async removeAccountContext(
+        account: AccountEntity,
+        correlationId: string
+    ): Promise<void> {
         const allTokenKeys = this.getTokenKeys();
         const accountId = account.generateAccountId();
-        const removedCredentials: Array<Promise<void>> = [];
 
         allTokenKeys.idToken.forEach((key) => {
             if (key.indexOf(accountId) === 0) {
-                this.removeIdToken(key);
+                this.removeIdToken(key, correlationId);
             }
         });
 
         allTokenKeys.accessToken.forEach((key) => {
             if (key.indexOf(accountId) === 0) {
-                removedCredentials.push(this.removeAccessToken(key));
+                this.removeAccessToken(key, correlationId);
             }
         });
 
         allTokenKeys.refreshToken.forEach((key) => {
             if (key.indexOf(accountId) === 0) {
-                this.removeRefreshToken(key);
+                this.removeRefreshToken(key, correlationId);
             }
         });
 
-        await Promise.all(removedCredentials);
+        this.getKeys().forEach((key) => {
+            if (key.includes(accountId)) {
+                this.removeItem(key, correlationId);
+            }
+        });
     }
 
     /**
@@ -1017,6 +1066,7 @@ export abstract class CacheManager implements ICacheManager {
     protected updateOutdatedCachedAccount(
         accountKey: string,
         accountEntity: AccountEntity | null,
+        correlationId: string,
         logger?: Logger
     ): AccountEntity | null {
         // Only update if account entity is defined and has no tenantProfiles object (is outdated)
@@ -1035,7 +1085,7 @@ export abstract class CacheManager implements ICacheManager {
             // Get all account entities belonging to user
             const accountsToMerge: AccountEntity[] = [];
             matchingAccountKeys.forEach((key: string) => {
-                const account = this.getCachedAccountEntity(key);
+                const account = this.getCachedAccountEntity(key, correlationId);
                 if (account) {
                     accountsToMerge.push(account);
                 }
@@ -1074,12 +1124,12 @@ export abstract class CacheManager implements ICacheManager {
             // Clear cache of legacy account objects that have been collpsed into tenant profiles
             matchingAccountKeys.forEach((key: string) => {
                 if (key !== newAccountKey) {
-                    this.removeOutdatedAccount(accountKey);
+                    this.removeOutdatedAccount(accountKey, correlationId);
                 }
             });
 
             // Cache updated account object
-            this.setAccount(updatedAccount);
+            this.setAccount(updatedAccount, correlationId);
             logger?.verbose("Updated an outdated account entity in the cache");
             return updatedAccount;
         }
@@ -1092,45 +1142,37 @@ export abstract class CacheManager implements ICacheManager {
      * returns a boolean if the given credential is removed
      * @param credential
      */
-    async removeAccessToken(key: string): Promise<void> {
-        const credential = this.getAccessTokenCredential(key);
-        if (!credential) {
-            return;
-        }
+    removeAccessToken(key: string, correlationId: string): void {
+        const credential = this.getAccessTokenCredential(key, correlationId);
+        this.removeItem(key, correlationId);
 
-        // Remove Token Binding Key from key store for PoP Tokens Credentials
         if (
-            credential.credentialType.toLowerCase() ===
-            CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME.toLowerCase()
+            !credential ||
+            credential.credentialType.toLowerCase() !==
+                CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME.toLowerCase() ||
+            credential.tokenType !== AuthenticationScheme.POP
         ) {
-            if (credential.tokenType === AuthenticationScheme.POP) {
-                const accessTokenWithAuthSchemeEntity =
-                    credential as AccessTokenEntity;
-                const kid = accessTokenWithAuthSchemeEntity.keyId;
-
-                if (kid) {
-                    try {
-                        await this.cryptoImpl.removeTokenBindingKey(kid);
-                    } catch (error) {
-                        throw createClientAuthError(
-                            ClientAuthErrorCodes.bindingKeyNotRemoved
-                        );
-                    }
-                }
-            }
+            return;
         }
 
-        return this.removeItem(key);
+        // Remove Token Binding Key from key store for PoP Tokens Credentials
+        const kid = credential.keyId;
+
+        if (kid) {
+            void this.cryptoImpl.removeTokenBindingKey(kid).catch(() => {
+                this.commonLogger.error("Binding key could not be removed");
+            });
+        }
     }
 
     /**
      * Removes all app metadata objects from cache.
      */
-    removeAppMetadata(): boolean {
+    removeAppMetadata(correlationId: string): boolean {
         const allCacheKeys = this.getKeys();
         allCacheKeys.forEach((cacheKey) => {
             if (this.isAppMetadata(cacheKey)) {
-                this.removeItem(cacheKey);
+                this.removeItem(cacheKey, correlationId);
             }
         });
 
@@ -1141,10 +1183,13 @@ export abstract class CacheManager implements ICacheManager {
      * Retrieve AccountEntity from cache
      * @param account
      */
-    readAccountFromCache(account: AccountInfo): AccountEntity | null {
+    readAccountFromCache(
+        account: AccountInfo,
+        correlationId: string
+    ): AccountEntity | null {
         const accountKey: string =
             AccountEntity.generateAccountCacheKey(account);
-        return this.getAccount(accountKey, this.commonLogger);
+        return this.getAccount(accountKey, correlationId, this.commonLogger);
     }
 
     /**
@@ -1157,10 +1202,10 @@ export abstract class CacheManager implements ICacheManager {
      */
     getIdToken(
         account: AccountInfo,
+        correlationId: string,
         tokenKeys?: TokenKeys,
         targetRealm?: string,
-        performanceClient?: IPerformanceClient,
-        correlationId?: string
+        performanceClient?: IPerformanceClient
     ): IdTokenEntity | null {
         this.commonLogger.trace("CacheManager - getIdToken called");
         const idTokenFilter: CredentialFilter = {
@@ -1173,6 +1218,7 @@ export abstract class CacheManager implements ICacheManager {
 
         const idTokenMap: Map<string, IdTokenEntity> = this.getIdTokensByFilter(
             idTokenFilter,
+            correlationId,
             tokenKeys
         );
 
@@ -1215,7 +1261,7 @@ export abstract class CacheManager implements ICacheManager {
                 "CacheManager:getIdToken - Multiple matching ID tokens found, clearing them"
             );
             tokensToBeRemoved.forEach((idToken, key) => {
-                this.removeIdToken(key);
+                this.removeIdToken(key, correlationId);
             });
             if (performanceClient && correlationId) {
                 performanceClient.addFields(
@@ -1237,6 +1283,7 @@ export abstract class CacheManager implements ICacheManager {
      */
     getIdTokensByFilter(
         filter: CredentialFilter,
+        correlationId: string,
         tokenKeys?: TokenKeys
     ): Map<string, IdTokenEntity> {
         const idTokenKeys =
@@ -1255,7 +1302,7 @@ export abstract class CacheManager implements ICacheManager {
             ) {
                 return;
             }
-            const idToken = this.getIdTokenCredential(key);
+            const idToken = this.getIdTokenCredential(key, correlationId);
             if (idToken && this.credentialMatchesFilter(idToken, filter)) {
                 idTokens.set(key, idToken);
             }
@@ -1296,16 +1343,16 @@ export abstract class CacheManager implements ICacheManager {
      * Removes idToken from the cache
      * @param key
      */
-    removeIdToken(key: string): void {
-        this.removeItem(key);
+    removeIdToken(key: string, correlationId: string): void {
+        this.removeItem(key, correlationId);
     }
 
     /**
      * Removes refresh token from the cache
      * @param key
      */
-    removeRefreshToken(key: string): void {
-        this.removeItem(key);
+    removeRefreshToken(key: string, correlationId: string): void {
+        this.removeItem(key, correlationId);
     }
 
     /**
@@ -1321,8 +1368,7 @@ export abstract class CacheManager implements ICacheManager {
         request: BaseAuthRequest,
         tokenKeys?: TokenKeys,
         targetRealm?: string,
-        performanceClient?: IPerformanceClient,
-        correlationId?: string
+        performanceClient?: IPerformanceClient
     ): AccessTokenEntity | null {
         this.commonLogger.trace("CacheManager - getAccessToken called");
         const scopes = ScopeSet.createSearchScopes(request.scopes);
@@ -1361,7 +1407,10 @@ export abstract class CacheManager implements ICacheManager {
             if (
                 this.accessTokenKeyMatchesFilter(key, accessTokenFilter, true)
             ) {
-                const accessToken = this.getAccessTokenCredential(key);
+                const accessToken = this.getAccessTokenCredential(
+                    key,
+                    request.correlationId
+                );
 
                 // Validate value
                 if (
@@ -1384,12 +1433,15 @@ export abstract class CacheManager implements ICacheManager {
                 "CacheManager:getAccessToken - Multiple access tokens found, clearing them"
             );
             accessTokens.forEach((accessToken) => {
-                void this.removeAccessToken(generateCredentialKey(accessToken));
+                void this.removeAccessToken(
+                    generateCredentialKey(accessToken),
+                    request.correlationId
+                );
             });
-            if (performanceClient && correlationId) {
+            if (performanceClient && request.correlationId) {
                 performanceClient.addFields(
                     { multiMatchedAT: accessTokens.length },
-                    correlationId
+                    request.correlationId
                 );
             }
             return null;
@@ -1466,7 +1518,10 @@ export abstract class CacheManager implements ICacheManager {
      * @param filter
      * @returns
      */
-    getAccessTokensByFilter(filter: CredentialFilter): AccessTokenEntity[] {
+    getAccessTokensByFilter(
+        filter: CredentialFilter,
+        correlationId: string
+    ): AccessTokenEntity[] {
         const tokenKeys = this.getTokenKeys();
 
         const accessTokens: AccessTokenEntity[] = [];
@@ -1475,7 +1530,10 @@ export abstract class CacheManager implements ICacheManager {
                 return;
             }
 
-            const accessToken = this.getAccessTokenCredential(key);
+            const accessToken = this.getAccessTokenCredential(
+                key,
+                correlationId
+            );
             if (
                 accessToken &&
                 this.credentialMatchesFilter(accessToken, filter)
@@ -1498,9 +1556,9 @@ export abstract class CacheManager implements ICacheManager {
     getRefreshToken(
         account: AccountInfo,
         familyRT: boolean,
+        correlationId: string,
         tokenKeys?: TokenKeys,
-        performanceClient?: IPerformanceClient,
-        correlationId?: string
+        performanceClient?: IPerformanceClient
     ): RefreshTokenEntity | null {
         this.commonLogger.trace("CacheManager - getRefreshToken called");
         const id = familyRT ? THE_FAMILY_ID : undefined;
@@ -1520,7 +1578,10 @@ export abstract class CacheManager implements ICacheManager {
         refreshTokenKeys.forEach((key) => {
             // Validate key
             if (this.refreshTokenKeyMatchesFilter(key, refreshTokenFilter)) {
-                const refreshToken = this.getRefreshTokenCredential(key);
+                const refreshToken = this.getRefreshTokenCredential(
+                    key,
+                    correlationId
+                );
                 // Validate value
                 if (
                     refreshToken &&