@azure/msal-common 15.13.3 → 16.0.0-beta.0

package/src/logger/Logger.ts

@@ -4,7 +4,6 @@
  */
 
 import type { LoggerOptions } from "../config/ClientConfiguration.js";
-import { Constants } from "../utils/Constants.js";
 
 /**
  * Options for logger messages.
@@ -13,7 +12,7 @@ export type LoggerMessageOptions = {
     logLevel: LogLevel;
     containsPii?: boolean;
     context?: string;
-    correlationId?: string;
+    correlationId: string;
 };
 
 /**
@@ -34,13 +33,145 @@ export interface ILoggerCallback {
     (level: LogLevel, message: string, containsPii: boolean): void;
 }
 
+/**
+ * Represents a single logged message with metadata
+ */
+export interface LoggedMessage {
+    hash: string;
+    level: LogLevel;
+    containsPii: boolean;
+    milliseconds: number;
+}
+
+/**
+ * LRU cache node for correlation ID management
+ */
+interface CorrelationLogData {
+    logs: LoggedMessage[];
+    firstEventTime: number;
+}
+
+// Shared cache state for better minification - using Map's insertion order for LRU
+const CACHE_CAPACITY = 50;
+const MAX_LOGS_PER_CORRELATION = 500;
+const correlationCache = new Map<string, CorrelationLogData>();
+
+/**
+ * Mark correlation ID as recently used by moving it to end of Map
+ * @param correlationId
+ * @param {CorrelationLogData} data
+ */
+function markAsRecentlyUsed(
+    correlationId: string,
+    data: CorrelationLogData
+): void {
+    correlationCache.delete(correlationId);
+    correlationCache.set(correlationId, data);
+}
+
+/**
+ * Add log message to cache for specific correlation ID
+ * @param correlationId
+ * @param {LoggedMessage} loggedMessage
+ */
+function addLogToCache(
+    correlationId: string,
+    loggedMessage: LoggedMessage
+): void {
+    const currentTime = Date.now();
+
+    let data = correlationCache.get(correlationId);
+
+    if (data) {
+        // Mark as recently used
+        markAsRecentlyUsed(correlationId, data);
+    } else {
+        // Create new entry
+        data = { logs: [], firstEventTime: currentTime };
+        correlationCache.set(correlationId, data);
+
+        // Remove LRU (first entry) if capacity exceeded
+        if (correlationCache.size > CACHE_CAPACITY) {
+            const firstKey = correlationCache.keys().next().value;
+            if (firstKey) {
+                correlationCache.delete(firstKey);
+            }
+        }
+    }
+
+    // Add log to the data, maintaining max logs per correlation
+    data.logs.push({
+        ...loggedMessage,
+        milliseconds: currentTime - data.firstEventTime,
+    });
+    if (data.logs.length > MAX_LOGS_PER_CORRELATION) {
+        data.logs.shift(); // Remove oldest log
+    }
+}
+
+/**
+ * Get all logs for specific correlation ID
+ * @param correlationId
+ */
+export function getLogsFromCache(correlationId: string): LoggedMessage[] {
+    const data = correlationCache.get(correlationId);
+    if (data) {
+        markAsRecentlyUsed(correlationId, data);
+        return [...data.logs]; // Return copy
+    }
+    return [];
+}
+
+/**
+ * Get logs for correlation ID and flush them from cache
+ * Attaches logs with empty correlation id to the requested correlation logs
+ * @param correlationId
+ */
+export function getAndFlushLogsFromCache(
+    correlationId: string
+): LoggedMessage[] {
+    const res: LoggedMessage[] = [];
+    for (const id of ["", correlationId]) {
+        const data = correlationCache.get(id);
+        res.push(...(data?.logs ?? []));
+        correlationCache.delete(id); // Remove the correlation ID completely from cache
+    }
+    return res;
+}
+
+/**
+ * Get all correlation IDs that have logs
+ */
+export function getCachedCorrelationIds(): string[] {
+    return Array.from(correlationCache.keys());
+}
+
+/**
+ * Checks if a string is already a hashed logging string (6 alphanumeric characters)
+ */
+function isHashedString(str: string): boolean {
+    if (str.length !== 6) {
+        return false;
+    }
+
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        const isAlphaNumeric =
+            (char >= "a" && char <= "z") ||
+            (char >= "A" && char <= "Z") ||
+            (char >= "0" && char <= "9");
+        if (!isAlphaNumeric) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
 /**
  * Class which facilitates logging of messages to a specific place.
  */
 export class Logger {
-    // Correlation ID for request, usually set by user.
-    private correlationId: string;
-
     // Current log level, defaults to info.
     private level: LogLevel = LogLevel.Info;
 
@@ -73,10 +204,8 @@ export class Logger {
             typeof setLoggerOptions.logLevel === "number"
                 ? setLoggerOptions.logLevel
                 : LogLevel.Info;
-        this.correlationId =
-            setLoggerOptions.correlationId || Constants.EMPTY_STRING;
-        this.packageName = packageName || Constants.EMPTY_STRING;
-        this.packageVersion = packageVersion || Constants.EMPTY_STRING;
+        this.packageName = packageName || "";
+        this.packageVersion = packageVersion || "";
     }
 
     private static createDefaultLoggerOptions(): LoggerOptions {
@@ -92,17 +221,12 @@ export class Logger {
     /**
      * Create new Logger with existing configurations.
      */
-    public clone(
-        packageName: string,
-        packageVersion: string,
-        correlationId?: string
-    ): Logger {
+    public clone(packageName: string, packageVersion: string): Logger {
         return new Logger(
             {
                 loggerCallback: this.localCallback,
                 piiLoggingEnabled: this.piiLoggingEnabled,
                 logLevel: this.level,
-                correlationId: correlationId || this.correlationId,
             },
             packageName,
             packageVersion
@@ -116,6 +240,19 @@ export class Logger {
         logMessage: string,
         options: LoggerMessageOptions
     ): void {
+        const correlationId = options.correlationId;
+        const isHashedInput = isHashedString(logMessage);
+
+        if (isHashedInput) {
+            const loggedMessage: LoggedMessage = {
+                hash: logMessage,
+                level: options.logLevel,
+                containsPii: options.containsPii || false,
+                milliseconds: 0, // Will be calculated in addLogToCache
+            };
+            addLogToCache(correlationId, loggedMessage);
+        }
+
         if (
             options.logLevel > this.level ||
             (!this.piiLoggingEnabled && options.containsPii)
@@ -125,14 +262,12 @@ export class Logger {
         const timestamp = new Date().toUTCString();
 
         // Add correlationId to logs if set, correlationId provided on log messages take precedence
-        const logHeader = `[${timestamp}] : [${
-            options.correlationId || this.correlationId || ""
-        }]`;
+        const logHeader = `[${timestamp}] : [${correlationId}]`;
 
         const log = `${logHeader} : ${this.packageName}@${
             this.packageVersion
         } : ${LogLevel[options.logLevel]} - ${logMessage}`;
-        // debug(`msal:${LogLevel[options.logLevel]}${options.containsPii ? "-Pii": Constants.EMPTY_STRING}${options.context ? `:${options.context}` : Constants.EMPTY_STRING}`)(logMessage);
+
         this.executeCallback(
             options.logLevel,
             log,
@@ -156,110 +291,110 @@ export class Logger {
     /**
      * Logs error messages.
      */
-    error(message: string, correlationId?: string): void {
+    error(message: string, correlationId: string): void {
         this.logMessage(message, {
             logLevel: LogLevel.Error,
             containsPii: false,
-            correlationId: correlationId || Constants.EMPTY_STRING,
+            correlationId: correlationId,
         });
     }
 
     /**
      * Logs error messages with PII.
      */
-    errorPii(message: string, correlationId?: string): void {
+    errorPii(message: string, correlationId: string): void {
         this.logMessage(message, {
             logLevel: LogLevel.Error,
             containsPii: true,
-            correlationId: correlationId || Constants.EMPTY_STRING,
+            correlationId: correlationId,
         });
     }
 
     /**
      * Logs warning messages.
      */
-    warning(message: string, correlationId?: string): void {
+    warning(message: string, correlationId: string): void {
         this.logMessage(message, {
             logLevel: LogLevel.Warning,
             containsPii: false,
-            correlationId: correlationId || Constants.EMPTY_STRING,
+            correlationId: correlationId,
         });
     }
 
     /**
      * Logs warning messages with PII.
      */
-    warningPii(message: string, correlationId?: string): void {
+    warningPii(message: string, correlationId: string): void {
         this.logMessage(message, {
             logLevel: LogLevel.Warning,
             containsPii: true,
-            correlationId: correlationId || Constants.EMPTY_STRING,
+            correlationId: correlationId,
         });
     }
 
     /**
      * Logs info messages.
      */
-    info(message: string, correlationId?: string): void {
+    info(message: string, correlationId: string): void {
         this.logMessage(message, {
             logLevel: LogLevel.Info,
             containsPii: false,
-            correlationId: correlationId || Constants.EMPTY_STRING,
+            correlationId: correlationId,
         });
     }
 
     /**
      * Logs info messages with PII.
      */
-    infoPii(message: string, correlationId?: string): void {
+    infoPii(message: string, correlationId: string): void {
         this.logMessage(message, {
             logLevel: LogLevel.Info,
             containsPii: true,
-            correlationId: correlationId || Constants.EMPTY_STRING,
+            correlationId: correlationId,
         });
     }
 
     /**
      * Logs verbose messages.
      */
-    verbose(message: string, correlationId?: string): void {
+    verbose(message: string, correlationId: string): void {
         this.logMessage(message, {
             logLevel: LogLevel.Verbose,
             containsPii: false,
-            correlationId: correlationId || Constants.EMPTY_STRING,
+            correlationId: correlationId,
         });
     }
 
     /**
      * Logs verbose messages with PII.
      */
-    verbosePii(message: string, correlationId?: string): void {
+    verbosePii(message: string, correlationId: string): void {
         this.logMessage(message, {
             logLevel: LogLevel.Verbose,
             containsPii: true,
-            correlationId: correlationId || Constants.EMPTY_STRING,
+            correlationId: correlationId,
         });
     }
 
     /**
      * Logs trace messages.
      */
-    trace(message: string, correlationId?: string): void {
+    trace(message: string, correlationId: string): void {
         this.logMessage(message, {
             logLevel: LogLevel.Trace,
             containsPii: false,
-            correlationId: correlationId || Constants.EMPTY_STRING,
+            correlationId: correlationId,
         });
     }
 
     /**
      * Logs trace messages with PII.
      */
-    tracePii(message: string, correlationId?: string): void {
+    tracePii(message: string, correlationId: string): void {
         this.logMessage(message, {
             logLevel: LogLevel.Trace,
             containsPii: true,
-            correlationId: correlationId || Constants.EMPTY_STRING,
+            correlationId: correlationId,
         });
     }
 

package/src/network/RequestThumbprint.ts

@@ -42,6 +42,6 @@ export function getRequestThumbprint(
         shrClaims: request.shrClaims,
         sshKid: request.sshKid,
         embeddedClientId:
-            request.embeddedClientId || request.tokenBodyParameters?.clientId,
+            request.embeddedClientId || request.extraParameters?.clientId,
     };
 }

package/src/network/ThrottlingUtils.ts

@@ -5,11 +5,7 @@
 
 import { NetworkResponse } from "./NetworkResponse.js";
 import { ServerAuthorizationTokenResponse } from "../response/ServerAuthorizationTokenResponse.js";
-import {
-    HeaderNames,
-    ThrottlingConstants,
-    Constants,
-} from "../utils/Constants.js";
+import * as Constants from "../utils/Constants.js";
 import { CacheManager } from "../cache/CacheManager.js";
 import { ServerError } from "../error/ServerError.js";
 import {
@@ -26,9 +22,7 @@ export class ThrottlingUtils {
      * @param thumbprint
      */
     static generateThrottlingStorageKey(thumbprint: RequestThumbprint): string {
-        return `${ThrottlingConstants.THROTTLING_PREFIX}.${JSON.stringify(
-            thumbprint
-        )}`;
+        return `${Constants.THROTTLING_PREFIX}.${JSON.stringify(thumbprint)}`;
     }
 
     /**
@@ -42,7 +36,7 @@ export class ThrottlingUtils {
         correlationId: string
     ): void {
         const key = ThrottlingUtils.generateThrottlingStorageKey(thumbprint);
-        const value = cacheManager.getThrottlingCache(key);
+        const value = cacheManager.getThrottlingCache(key, correlationId);
 
         if (value) {
             if (value.throttleTime < Date.now()) {
@@ -50,7 +44,7 @@ export class ThrottlingUtils {
                 return;
             }
             throw new ServerError(
-                value.errorCodes?.join(" ") || Constants.EMPTY_STRING,
+                value.errorCodes?.join(" ") || "",
                 value.errorMessage,
                 value.subError
             );
@@ -75,7 +69,9 @@ export class ThrottlingUtils {
         ) {
             const thumbprintValue: ThrottlingEntity = {
                 throttleTime: ThrottlingUtils.calculateThrottleTime(
-                    parseInt(response.headers[HeaderNames.RETRY_AFTER])
+                    parseInt(
+                        response.headers[Constants.HeaderNames.RETRY_AFTER]
+                    )
                 ),
                 error: response.body.error,
                 errorCodes: response.body.error_codes,
@@ -112,7 +108,9 @@ export class ThrottlingUtils {
     ): boolean {
         if (response.headers) {
             return (
-                response.headers.hasOwnProperty(HeaderNames.RETRY_AFTER) &&
+                response.headers.hasOwnProperty(
+                    Constants.HeaderNames.RETRY_AFTER
+                ) &&
                 (response.status < 200 || response.status >= 300)
             );
         }
@@ -130,9 +128,8 @@ export class ThrottlingUtils {
         return Math.floor(
             Math.min(
                 currentSeconds +
-                    (time || ThrottlingConstants.DEFAULT_THROTTLE_TIME_SECONDS),
-                currentSeconds +
-                    ThrottlingConstants.DEFAULT_MAX_THROTTLE_TIME_SECONDS
+                    (time || Constants.DEFAULT_THROTTLE_TIME_SECONDS),
+                currentSeconds + Constants.DEFAULT_MAX_THROTTLE_TIME_SECONDS
             ) * 1000
         );
     }

package/src/packageMetadata.ts

@@ -1,3 +1,3 @@
 /* eslint-disable header/header */
 export const name = "@azure/msal-common";
-export const version = "15.13.3";
+export const version = "16.0.0-beta.0";

package/src/protocol/Authorize.ts

@@ -26,7 +26,6 @@ import {
     isInteractionRequiredError,
 } from "../error/InteractionRequiredAuthError.js";
 import { ServerError } from "../error/ServerError.js";
-import { StringDict } from "../utils/MsalTypes.js";
 
 /**
  * Returns map of parameters that are applicable to all calls to /authorize whether using PKCE or EAR
@@ -94,7 +93,8 @@ export function getStandardAuthorizeRequestParameters(
         if (request.sid && request.prompt === PromptValue.NONE) {
             // SessionID is only used in silent calls
             logger.verbose(
-                "createAuthCodeUrlQueryString: Prompt is none, adding sid from request"
+                "createAuthCodeUrlQueryString: Prompt is none, adding sid from request",
+                request.correlationId
             );
             RequestParameterBuilder.addSid(parameters, request.sid);
             performanceClient?.addFields(
@@ -107,7 +107,8 @@ export function getStandardAuthorizeRequestParameters(
 
             if (accountLoginHintClaim && request.domainHint) {
                 logger.warning(
-                    `AuthorizationCodeClient.createAuthCodeUrlQueryString: "domainHint" param is set, skipping opaque "login_hint" claim. Please consider not passing domainHint`
+                    `AuthorizationCodeClient.createAuthCodeUrlQueryString: "domainHint" param is set, skipping opaque "login_hint" claim. Please consider not passing domainHint`,
+                    request.correlationId
                 );
                 accountLoginHintClaim = null;
             }
@@ -115,7 +116,8 @@ export function getStandardAuthorizeRequestParameters(
             // If login_hint claim is present, use it over sid/username
             if (accountLoginHintClaim) {
                 logger.verbose(
-                    "createAuthCodeUrlQueryString: login_hint claim present on account"
+                    "createAuthCodeUrlQueryString: login_hint claim present on account",
+                    request.correlationId
                 );
                 RequestParameterBuilder.addLoginHint(
                     parameters,
@@ -132,7 +134,8 @@ export function getStandardAuthorizeRequestParameters(
                     RequestParameterBuilder.addCcsOid(parameters, clientInfo);
                 } catch (e) {
                     logger.verbose(
-                        "createAuthCodeUrlQueryString: Could not parse home account ID for CCS Header"
+                        "createAuthCodeUrlQueryString: Could not parse home account ID for CCS Header",
+                        request.correlationId
                     );
                 }
             } else if (accountSid && request.prompt === PromptValue.NONE) {
@@ -141,7 +144,8 @@ export function getStandardAuthorizeRequestParameters(
                  * SessionId is only used in silent calls
                  */
                 logger.verbose(
-                    "createAuthCodeUrlQueryString: Prompt is none, adding sid from account"
+                    "createAuthCodeUrlQueryString: Prompt is none, adding sid from account",
+                    request.correlationId
                 );
                 RequestParameterBuilder.addSid(parameters, accountSid);
                 performanceClient?.addFields(
@@ -155,12 +159,14 @@ export function getStandardAuthorizeRequestParameters(
                     RequestParameterBuilder.addCcsOid(parameters, clientInfo);
                 } catch (e) {
                     logger.verbose(
-                        "createAuthCodeUrlQueryString: Could not parse home account ID for CCS Header"
+                        "createAuthCodeUrlQueryString: Could not parse home account ID for CCS Header",
+                        request.correlationId
                     );
                 }
             } else if (request.loginHint) {
                 logger.verbose(
-                    "createAuthCodeUrlQueryString: Adding login_hint from request"
+                    "createAuthCodeUrlQueryString: Adding login_hint from request",
+                    request.correlationId
                 );
                 RequestParameterBuilder.addLoginHint(
                     parameters,
@@ -177,7 +183,8 @@ export function getStandardAuthorizeRequestParameters(
             } else if (request.account.username) {
                 // Fallback to account username if provided
                 logger.verbose(
-                    "createAuthCodeUrlQueryString: Adding login_hint from account"
+                    "createAuthCodeUrlQueryString: Adding login_hint from account",
+                    request.correlationId
                 );
                 RequestParameterBuilder.addLoginHint(
                     parameters,
@@ -194,13 +201,15 @@ export function getStandardAuthorizeRequestParameters(
                     RequestParameterBuilder.addCcsOid(parameters, clientInfo);
                 } catch (e) {
                     logger.verbose(
-                        "createAuthCodeUrlQueryString: Could not parse home account ID for CCS Header"
+                        "createAuthCodeUrlQueryString: Could not parse home account ID for CCS Header",
+                        request.correlationId
                     );
                 }
             }
         } else if (request.loginHint) {
             logger.verbose(
-                "createAuthCodeUrlQueryString: No account, adding login_hint from request"
+                "createAuthCodeUrlQueryString: No account, adding login_hint from request",
+                request.correlationId
             );
             RequestParameterBuilder.addLoginHint(parameters, request.loginHint);
             RequestParameterBuilder.addCcsUpn(parameters, request.loginHint);
@@ -211,7 +220,8 @@ export function getStandardAuthorizeRequestParameters(
         }
     } else {
         logger.verbose(
-            "createAuthCodeUrlQueryString: Prompt is select_account, ignoring account hints"
+            "createAuthCodeUrlQueryString: Prompt is select_account, ignoring account hints",
+            request.correlationId
         );
     }
 
@@ -265,15 +275,9 @@ export function getStandardAuthorizeRequestParameters(
  */
 export function getAuthorizeUrl(
     authority: Authority,
-    requestParameters: Map<string, string>,
-    encodeParams?: boolean,
-    extraQueryParameters?: StringDict | undefined
+    requestParameters: Map<string, string>
 ): string {
-    const queryString = mapToQueryString(
-        requestParameters,
-        encodeParams,
-        extraQueryParameters
-    );
+    const queryString = mapToQueryString(requestParameters);
     return UrlString.appendQueryString(
         authority.authorizationEndpoint,
         queryString