@azure/msal-common 14.7.2-alpha.0 → 14.8.1

package/dist/index.cjs

@@ -1,4 +1,4 @@
-/*! @azure/msal-common v14.7.2-alpha.0 2024-03-04 */
+/*! @azure/msal-common v14.8.1 2024-03-27 */
 'use strict';
 'use strict';
 
@@ -66,20 +66,11 @@ const Constants = {
 };
 const HttpStatus = {
     SUCCESS_RANGE_START: 200,
-    SUCCESS: 200,
     SUCCESS_RANGE_END: 299,
     REDIRECT: 302,
     CLIENT_ERROR_RANGE_START: 400,
-    BAD_REQUEST: 400,
-    UNAUTHORIZED: 401,
-    NOT_FOUND: 404,
-    REQUEST_TIMEOUT: 408,
-    TOO_MANY_REQUESTS: 429,
     CLIENT_ERROR_RANGE_END: 499,
     SERVER_ERROR_RANGE_START: 500,
-    INTERNAL_SERVER_ERROR: 500,
-    SERVICE_UNAVAILABLE: 503,
-    GATEWAY_TIMEOUT: 504,
     SERVER_ERROR_RANGE_END: 599,
 };
 const OIDC_DEFAULT_SCOPES = [
@@ -319,8 +310,6 @@ const JsonWebTokenTypes = {
     Pop: "pop",
 };
 const ONE_DAY_IN_MS = 86400000;
-// Token renewal offset default in seconds
-const DEFAULT_TOKEN_RENEWAL_OFFSET_SEC = 300;
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -954,7 +943,7 @@ class Logger {
 
 /* eslint-disable header/header */
 const name = "@azure/msal-common";
-const version = "14.7.2-alpha.0";
+const version = "14.8.1";
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -3897,6 +3886,8 @@ class DefaultStorageClass extends CacheManager {
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
+// Token renewal offset default in seconds
+const DEFAULT_TOKEN_RENEWAL_OFFSET_SEC = 300;
 const DEFAULT_SYSTEM_OPTIONS = {
     tokenRenewalOffsetSeconds: DEFAULT_TOKEN_RENEWAL_OFFSET_SEC,
     preventCorsPreflight: false,
@@ -4984,6 +4975,219 @@ const PerformanceEvents = {
     Sha256Digest: "sha256Digest",
     GetRandomValues: "getRandomValues",
 };
+const PerformanceEventAbbreviations = new Map([
+    [PerformanceEvents.AcquireTokenByCode, "ATByCode"],
+    [PerformanceEvents.AcquireTokenByRefreshToken, "ATByRT"],
+    [PerformanceEvents.AcquireTokenSilent, "ATS"],
+    [PerformanceEvents.AcquireTokenSilentAsync, "ATSAsync"],
+    [PerformanceEvents.AcquireTokenPopup, "ATPopup"],
+    [PerformanceEvents.AcquireTokenRedirect, "ATRedirect"],
+    [
+        PerformanceEvents.CryptoOptsGetPublicKeyThumbprint,
+        "CryptoGetPKThumb",
+    ],
+    [PerformanceEvents.CryptoOptsSignJwt, "CryptoSignJwt"],
+    [PerformanceEvents.SilentCacheClientAcquireToken, "SltCacheClientAT"],
+    [PerformanceEvents.SilentIframeClientAcquireToken, "SltIframeClientAT"],
+    [PerformanceEvents.SilentRefreshClientAcquireToken, "SltRClientAT"],
+    [PerformanceEvents.SsoSilent, "SsoSlt"],
+    [
+        PerformanceEvents.StandardInteractionClientGetDiscoveredAuthority,
+        "StdIntClientGetDiscAuth",
+    ],
+    [
+        PerformanceEvents.FetchAccountIdWithNativeBroker,
+        "FetchAccIdWithNtvBroker",
+    ],
+    [
+        PerformanceEvents.NativeInteractionClientAcquireToken,
+        "NtvIntClientAT",
+    ],
+    [
+        PerformanceEvents.BaseClientCreateTokenRequestHeaders,
+        "BaseClientCreateTReqHead",
+    ],
+    [
+        PerformanceEvents.RefreshTokenClientExecutePostToTokenEndpoint,
+        "RTClientExecPost",
+    ],
+    [
+        PerformanceEvents.AuthorizationCodeClientExecutePostToTokenEndpoint,
+        "AuthCodeClientExecPost",
+    ],
+    [PerformanceEvents.BrokerHandhshake, "BrokerHandshake"],
+    [
+        PerformanceEvents.AcquireTokenByRefreshTokenInBroker,
+        "ATByRTInBroker",
+    ],
+    [PerformanceEvents.AcquireTokenByBroker, "ATByBroker"],
+    [
+        PerformanceEvents.RefreshTokenClientExecuteTokenRequest,
+        "RTClientExecTReq",
+    ],
+    [PerformanceEvents.RefreshTokenClientAcquireToken, "RTClientAT"],
+    [
+        PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken,
+        "RTClientATWithCachedRT",
+    ],
+    [
+        PerformanceEvents.RefreshTokenClientAcquireTokenByRefreshToken,
+        "RTClientATByRT",
+    ],
+    [
+        PerformanceEvents.RefreshTokenClientCreateTokenRequestBody,
+        "RTClientCreateTReqBody",
+    ],
+    [PerformanceEvents.AcquireTokenFromCache, "ATFromCache"],
+    [
+        PerformanceEvents.SilentFlowClientAcquireCachedToken,
+        "SltFlowClientATCached",
+    ],
+    [
+        PerformanceEvents.SilentFlowClientGenerateResultFromCacheRecord,
+        "SltFlowClientGenResFromCache",
+    ],
+    [PerformanceEvents.AcquireTokenBySilentIframe, "ATBySltIframe"],
+    [PerformanceEvents.InitializeBaseRequest, "InitBaseReq"],
+    [PerformanceEvents.InitializeSilentRequest, "InitSltReq"],
+    [
+        PerformanceEvents.InitializeClientApplication,
+        "InitClientApplication",
+    ],
+    [PerformanceEvents.SilentIframeClientTokenHelper, "SIClientTHelper"],
+    [
+        PerformanceEvents.SilentHandlerInitiateAuthRequest,
+        "SHandlerInitAuthReq",
+    ],
+    [
+        PerformanceEvents.SilentHandlerMonitorIframeForHash,
+        "SltHandlerMonitorIframeForHash",
+    ],
+    [PerformanceEvents.SilentHandlerLoadFrame, "SHandlerLoadFrame"],
+    [PerformanceEvents.SilentHandlerLoadFrameSync, "SHandlerLoadFrameSync"],
+    [
+        PerformanceEvents.StandardInteractionClientCreateAuthCodeClient,
+        "StdIntClientCreateAuthCodeClient",
+    ],
+    [
+        PerformanceEvents.StandardInteractionClientGetClientConfiguration,
+        "StdIntClientGetClientConf",
+    ],
+    [
+        PerformanceEvents.StandardInteractionClientInitializeAuthorizationRequest,
+        "StdIntClientInitAuthReq",
+    ],
+    [
+        PerformanceEvents.StandardInteractionClientInitializeAuthorizationCodeRequest,
+        "StdIntClientInitAuthCodeReq",
+    ],
+    [PerformanceEvents.GetAuthCodeUrl, "GetAuthCodeUrl"],
+    [
+        PerformanceEvents.HandleCodeResponseFromServer,
+        "HandleCodeResFromServer",
+    ],
+    [PerformanceEvents.HandleCodeResponse, "HandleCodeResp"],
+    [PerformanceEvents.UpdateTokenEndpointAuthority, "UpdTEndpointAuth"],
+    [PerformanceEvents.AuthClientAcquireToken, "AuthClientAT"],
+    [PerformanceEvents.AuthClientExecuteTokenRequest, "AuthClientExecTReq"],
+    [
+        PerformanceEvents.AuthClientCreateTokenRequestBody,
+        "AuthClientCreateTReqBody",
+    ],
+    [
+        PerformanceEvents.AuthClientCreateQueryString,
+        "AuthClientCreateQueryStr",
+    ],
+    [PerformanceEvents.PopTokenGenerateCnf, "PopTGenCnf"],
+    [PerformanceEvents.PopTokenGenerateKid, "PopTGenKid"],
+    [PerformanceEvents.HandleServerTokenResponse, "HandleServerTRes"],
+    [PerformanceEvents.DeserializeResponse, "DeserializeRes"],
+    [
+        PerformanceEvents.AuthorityFactoryCreateDiscoveredInstance,
+        "AuthFactCreateDiscInst",
+    ],
+    [
+        PerformanceEvents.AuthorityResolveEndpointsAsync,
+        "AuthResolveEndpointsAsync",
+    ],
+    [
+        PerformanceEvents.AuthorityResolveEndpointsFromLocalSources,
+        "AuthResolveEndpointsFromLocal",
+    ],
+    [
+        PerformanceEvents.AuthorityGetCloudDiscoveryMetadataFromNetwork,
+        "AuthGetCDMetaFromNet",
+    ],
+    [
+        PerformanceEvents.AuthorityUpdateCloudDiscoveryMetadata,
+        "AuthUpdCDMeta",
+    ],
+    [
+        PerformanceEvents.AuthorityGetEndpointMetadataFromNetwork,
+        "AuthUpdCDMetaFromNet",
+    ],
+    [
+        PerformanceEvents.AuthorityUpdateEndpointMetadata,
+        "AuthUpdEndpointMeta",
+    ],
+    [
+        PerformanceEvents.AuthorityUpdateMetadataWithRegionalInformation,
+        "AuthUpdMetaWithRegInfo",
+    ],
+    [PerformanceEvents.RegionDiscoveryDetectRegion, "RegDiscDetectReg"],
+    [
+        PerformanceEvents.RegionDiscoveryGetRegionFromIMDS,
+        "RegDiscGetRegFromIMDS",
+    ],
+    [
+        PerformanceEvents.RegionDiscoveryGetCurrentVersion,
+        "RegDiscGetCurrentVer",
+    ],
+    [PerformanceEvents.AcquireTokenByCodeAsync, "ATByCodeAsync"],
+    [
+        PerformanceEvents.GetEndpointMetadataFromNetwork,
+        "GetEndpointMetaFromNet",
+    ],
+    [
+        PerformanceEvents.GetCloudDiscoveryMetadataFromNetworkMeasurement,
+        "GetCDMetaFromNet",
+    ],
+    [
+        PerformanceEvents.HandleRedirectPromiseMeasurement,
+        "HandleRedirectPromise",
+    ],
+    [
+        PerformanceEvents.HandleNativeRedirectPromiseMeasurement,
+        "HandleNtvRedirectPromise",
+    ],
+    [
+        PerformanceEvents.UpdateCloudDiscoveryMetadataMeasurement,
+        "UpdateCDMeta",
+    ],
+    [
+        PerformanceEvents.UsernamePasswordClientAcquireToken,
+        "UserPassClientAT",
+    ],
+    [
+        PerformanceEvents.NativeMessageHandlerHandshake,
+        "NtvMsgHandlerHandshake",
+    ],
+    [PerformanceEvents.NativeGenerateAuthResult, "NtvGenAuthRes"],
+    [PerformanceEvents.RemoveHiddenIframe, "RemoveHiddenIframe"],
+    [
+        PerformanceEvents.ClearTokensAndKeysWithClaims,
+        "ClearTAndKeysWithClaims",
+    ],
+    [PerformanceEvents.CacheManagerGetRefreshToken, "CacheManagerGetRT"],
+    [PerformanceEvents.GeneratePkceCodes, "GenPkceCodes"],
+    [PerformanceEvents.GenerateCodeVerifier, "GenCodeVerifier"],
+    [
+        PerformanceEvents.GenerateCodeChallengeFromVerifier,
+        "GenCodeChallengeFromVerifier",
+    ],
+    [PerformanceEvents.Sha256Digest, "Sha256Digest"],
+    [PerformanceEvents.GetRandomValues, "GetRandomValues"],
+]);
 /**
  * State of the performance event.
  *
@@ -5053,7 +5257,7 @@ const invoke = (callback, eventName, logger, telemetryClient, correlationId) =>
             }
             inProgressEvent?.end({
                 success: false,
-            });
+            }, e);
             throw e;
         }
     };
@@ -5099,7 +5303,7 @@ const invokeAsync = (callback, eventName, logger, telemetryClient, correlationId
             }
             inProgressEvent?.end({
                 success: false,
-            });
+            }, e);
             throw e;
         });
     };
@@ -5222,7 +5426,7 @@ RegionDiscovery.IMDS_OPTIONS = {
  * @internal
  */
 class Authority {
-    constructor(authority, networkInterface, cacheManager, authorityOptions, logger, correlationId, performanceClient, managedIdentity) {
+    constructor(authority, networkInterface, cacheManager, authorityOptions, logger, correlationId, performanceClient) {
         this.canonicalAuthority = authority;
         this._canonicalAuthority.validateAsUri();
         this.networkInterface = networkInterface;
@@ -5236,7 +5440,6 @@ class Authority {
         this.logger = logger;
         this.performanceClient = performanceClient;
         this.correlationId = correlationId;
-        this.managedIdentity = managedIdentity || false;
         this.regionDiscovery = new RegionDiscovery(networkInterface, this.logger, this.performanceClient, this.correlationId);
     }
     /**
@@ -5442,7 +5645,7 @@ class Authority {
         return `${this.canonicalAuthority}v2.0/.well-known/openid-configuration`;
     }
     /**
-     * Boolean that returns whether or not tenant discovery has been completed.
+     * Boolean that returns whethr or not tenant discovery has been completed.
      */
     discoveryComplete() {
         return !!this.metadata;
@@ -5894,10 +6097,7 @@ class Authority {
      * helper function to generate environment from authority object
      */
     getPreferredCache() {
-        if (this.managedIdentity) {
-            return Constants.DEFAULT_AUTHORITY_HOST;
-        }
-        else if (this.discoveryComplete()) {
+        if (this.discoveryComplete()) {
             return this.metadata.preferred_cache;
         }
         else {
@@ -8001,6 +8201,162 @@ class StubPerformanceClient {
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
+/**
+ * Starts context by adding payload to the stack
+ * @param event {PerformanceEvent}
+ * @param abbreviations {Map<string, string>} event name abbreviations
+ * @param stack {?PerformanceEventStackedContext[]} stack
+ */
+function startContext(event, abbreviations, stack) {
+    if (!stack) {
+        return;
+    }
+    stack.push({
+        name: abbreviations.get(event.name) || event.name,
+    });
+}
+/**
+ * Ends context by removing payload from the stack and returning parent or self, if stack is empty, payload
+ *
+ * @param event {PerformanceEvent}
+ * @param abbreviations {Map<string, string>} event name abbreviations
+ * @param stack {?PerformanceEventStackedContext[]} stack
+ * @param error {?unknown} error
+ */
+function endContext(event, abbreviations, stack, error) {
+    if (!stack?.length) {
+        return;
+    }
+    const peek = (stack) => {
+        return stack.length ? stack[stack.length - 1] : undefined;
+    };
+    const abbrEventName = abbreviations.get(event.name) || event.name;
+    const top = peek(stack);
+    if (top?.name !== abbrEventName) {
+        return;
+    }
+    const current = stack?.pop();
+    if (!current) {
+        return;
+    }
+    const errorCode = error instanceof AuthError
+        ? error.errorCode
+        : error instanceof Error
+            ? error.name
+            : undefined;
+    const subErr = error instanceof AuthError ? error.subError : undefined;
+    if (errorCode && current.childErr !== errorCode) {
+        current.err = errorCode;
+        if (subErr) {
+            current.subErr = subErr;
+        }
+    }
+    delete current.name;
+    delete current.childErr;
+    const context = {
+        ...current,
+        dur: event.durationMs,
+    };
+    if (!event.success) {
+        context.fail = 1;
+    }
+    const parent = peek(stack);
+    if (!parent) {
+        return { [abbrEventName]: context };
+    }
+    if (errorCode) {
+        parent.childErr = errorCode;
+    }
+    let childName;
+    if (!parent[abbrEventName]) {
+        childName = abbrEventName;
+    }
+    else {
+        const siblings = Object.keys(parent).filter((key) => key.startsWith(abbrEventName)).length;
+        childName = `${abbrEventName}_${siblings + 1}`;
+    }
+    parent[childName] = context;
+    return parent;
+}
+/**
+ * Adds error name and stack trace to the telemetry event
+ * @param error {Error}
+ * @param logger {Logger}
+ * @param event {PerformanceEvent}
+ * @param stackMaxSize {number} max error stack size to capture
+ */
+function addError(error, logger, event, stackMaxSize = 5) {
+    if (!(error instanceof Error)) {
+        logger.trace("PerformanceClient.addErrorStack: Input error is not instance of Error", event.correlationId);
+        return;
+    }
+    else if (error instanceof AuthError) {
+        event.errorCode = error.errorCode;
+        event.subErrorCode = error.subError;
+        return;
+    }
+    else if (event.errorStack?.length) {
+        logger.trace("PerformanceClient.addErrorStack: Stack already exist", event.correlationId);
+        return;
+    }
+    else if (!error.stack?.length) {
+        logger.trace("PerformanceClient.addErrorStack: Input stack is empty", event.correlationId);
+        return;
+    }
+    if (error.stack) {
+        event.errorStack = compactStack(error.stack, stackMaxSize);
+    }
+    event.errorName = error.name;
+}
+/**
+ * Compacts error stack into array by fetching N first entries
+ * @param stack {string} error stack
+ * @param stackMaxSize {number} max error stack size to capture
+ * @returns {string[]}
+ */
+function compactStack(stack, stackMaxSize) {
+    if (stackMaxSize < 0) {
+        return [];
+    }
+    const stackArr = stack.split("\n") || [];
+    if (stackArr.length < 2) {
+        return [];
+    }
+    const res = [];
+    // Get top N stack lines
+    for (
+    // Skip first line as it may contain PII data
+    let ix = Math.max(stackArr.length - stackMaxSize - 1, 1); ix < stackArr.length; ix++) {
+        const line = stackArr[ix];
+        if (res.length >= stackMaxSize) {
+            break;
+        }
+        res.push(compactStackLine(line));
+    }
+    return res;
+}
+/**
+ * Compacts error stack line by shortening file path
+ * Example: https://localhost/msal-common/src/authority/Authority.js:100:1 -> Authority.js:100:1
+ * @param line {string} stack line
+ * @returns {string}
+ */
+function compactStackLine(line) {
+    const filePathIx = line.lastIndexOf(" ") + 1;
+    if (filePathIx < 1) {
+        return line;
+    }
+    const filePath = line.substring(filePathIx);
+    let fileNameIx = filePath.lastIndexOf("/");
+    fileNameIx = fileNameIx < 0 ? filePath.lastIndexOf("\\") : fileNameIx;
+    if (fileNameIx >= 0) {
+        return (line.substring(0, filePathIx) +
+            "(" +
+            filePath.substring(fileNameIx + 1) +
+            (filePath.charAt(filePath.length - 1) === ")" ? "" : ")")).trimStart();
+    }
+    return line.trimStart();
+}
 class PerformanceClient {
     /**
      * Creates an instance of PerformanceClient,
@@ -8014,8 +8370,9 @@ class PerformanceClient {
      * @param {string} libraryVersion Version of the library
      * @param {ApplicationTelemetry} applicationTelemetry application name and version
      * @param {Set<String>} intFields integer fields to be truncated
+     * @param {Map<string, string>} abbreviations event name abbreviations
      */
-    constructor(clientId, authority, logger, libraryName, libraryVersion, applicationTelemetry, intFields) {
+    constructor(clientId, authority, logger, libraryName, libraryVersion, applicationTelemetry, intFields, abbreviations) {
         this.authority = authority;
         this.libraryName = libraryName;
         this.libraryVersion = libraryVersion;
@@ -8024,12 +8381,17 @@ class PerformanceClient {
         this.logger = logger;
         this.callbacks = new Map();
         this.eventsByCorrelationId = new Map();
+        this.eventStack = new Map();
         this.queueMeasurements = new Map();
         this.preQueueTimeByCorrelationId = new Map();
         this.intFields = intFields || new Set();
         for (const item of IntFields) {
             this.intFields.add(item);
         }
+        this.abbreviations = abbreviations || new Map();
+        for (const [key, value] of PerformanceEventAbbreviations) {
+            this.abbreviations.set(key, value);
+        }
     }
     /**
      * Starts and returns an platform-specific implementation of IPerformanceMeasurement.
@@ -8159,15 +8521,16 @@ class PerformanceClient {
         };
         // Store in progress events so they can be discarded if not ended properly
         this.cacheEventByCorrelationId(inProgressEvent);
+        startContext(inProgressEvent, this.abbreviations, this.eventStack.get(eventCorrelationId));
         // Return the event and functions the caller can use to properly end/flush the measurement
         return {
-            end: (event) => {
+            end: (event, error) => {
                 return this.endMeasurement({
                     // Initial set of event properties
                     ...inProgressEvent,
                     // Properties set when event ends
                     ...event,
-                });
+                }, error);
             },
             discard: () => {
                 return this.discardMeasurements(inProgressEvent.correlationId);
@@ -8189,10 +8552,10 @@ class PerformanceClient {
      * otherwise.
      *
      * @param {PerformanceEvent} event
-     * @param {IPerformanceMeasurement} measurement
+     * @param {unknown} error
      * @returns {(PerformanceEvent | null)}
      */
-    endMeasurement(event) {
+    endMeasurement(event, error) {
         const rootEvent = this.eventsByCorrelationId.get(event.correlationId);
         if (!rootEvent) {
             this.logger.trace(`PerformanceClient: Measurement not found for ${event.eventId}`, event.correlationId);
@@ -8204,6 +8567,8 @@ class PerformanceClient {
             totalQueueCount: 0,
             manuallyCompletedCount: 0,
         };
+        event.durationMs = Math.round(event.durationMs || this.getDurationMs(event.startTimeMs));
+        const context = JSON.stringify(endContext(event, this.abbreviations, this.eventStack.get(rootEvent.correlationId), error));
         if (isRoot) {
             queueInfo = this.getQueueInfo(event.correlationId);
             this.discardCache(rootEvent.correlationId);
@@ -8211,13 +8576,15 @@ class PerformanceClient {
         else {
             rootEvent.incompleteSubMeasurements?.delete(event.eventId);
         }
-        const durationMs = event.durationMs || this.getDurationMs(event.startTimeMs);
-        this.logger.trace(`PerformanceClient: Performance measurement ended for ${event.name}: ${durationMs} ms`, event.correlationId);
+        this.logger.trace(`PerformanceClient: Performance measurement ended for ${event.name}: ${event.durationMs} ms`, event.correlationId);
         // Add sub-measurement attribute to root event.
         if (!isRoot) {
-            rootEvent[event.name + "DurationMs"] = Math.floor(durationMs);
+            rootEvent[event.name + "DurationMs"] = Math.floor(event.durationMs);
             return { ...rootEvent };
         }
+        if (error) {
+            addError(error, this.logger, rootEvent);
+        }
         let finalEvent = { ...rootEvent, ...event };
         let incompleteSubsCount = 0;
         // Incomplete sub-measurements are discarded. They are likely an instrumentation bug that should be fixed.
@@ -8228,12 +8595,12 @@ class PerformanceClient {
         finalEvent.incompleteSubMeasurements = undefined;
         finalEvent = {
             ...finalEvent,
-            durationMs: Math.round(durationMs),
             queuedTimeMs: queueInfo.totalQueueTime,
             queuedCount: queueInfo.totalQueueCount,
             queuedManuallyCompletedCount: queueInfo.manuallyCompletedCount,
             status: PerformanceEventStatus.Completed,
             incompleteSubsCount,
+            context,
         };
         this.truncateIntegralFields(finalEvent);
         this.emitEvents([finalEvent], event.correlationId);
@@ -8303,6 +8670,7 @@ class PerformanceClient {
         else {
             this.logger.trace(`PerformanceClient: Performance measurement for ${event.name} started`, event.correlationId);
             this.eventsByCorrelationId.set(event.correlationId, { ...event });
+            this.eventStack.set(event.correlationId, []);
         }
     }
     getQueueInfo(correlationId) {
@@ -8344,6 +8712,8 @@ class PerformanceClient {
         this.queueMeasurements.delete(correlationId);
         this.logger.trace("PerformanceClient: Pre-queue times discarded", correlationId);
         this.preQueueTimeByCorrelationId.delete(correlationId);
+        this.logger.trace("PerformanceClient: Event stack discarded", correlationId);
+        this.eventStack.delete(correlationId);
     }
     /**
      * Registers a callback function to receive performance events.
@@ -8389,7 +8759,6 @@ class PerformanceClient {
     /**
      * Enforce truncation of integral fields in performance event.
      * @param {PerformanceEvent} event performance event to update.
-     * @param {Set<string>} intFields integral fields.
      */
     truncateIntegralFields(event) {
         this.intFields.forEach((key) => {
@@ -8444,7 +8813,6 @@ exports.Constants = Constants;
 exports.CredentialType = CredentialType;
 exports.DEFAULT_CRYPTO_IMPLEMENTATION = DEFAULT_CRYPTO_IMPLEMENTATION;
 exports.DEFAULT_SYSTEM_OPTIONS = DEFAULT_SYSTEM_OPTIONS;
-exports.DEFAULT_TOKEN_RENEWAL_OFFSET_SEC = DEFAULT_TOKEN_RENEWAL_OFFSET_SEC;
 exports.DefaultStorageClass = DefaultStorageClass;
 exports.Errors = Errors;
 exports.GrantType = GrantType;