@azure/msal-common 10.0.0 → 11.0.0

package/dist/index.cjs.js

@@ -1,4 +1,4 @@
-/*! @azure/msal-common v10.0.0 2023-02-06 */
+/*! @azure/msal-common v11.0.0 2023-03-07 */
 'use strict';
 'use strict';
 
@@ -486,6 +486,7 @@ var JsonTypes;
 (function (JsonTypes) {
     JsonTypes["Jwt"] = "JWT";
     JsonTypes["Jwk"] = "JWK";
+    JsonTypes["Pop"] = "pop";
 })(JsonTypes || (JsonTypes = {}));
 var ONE_DAY_IN_MS = 86400000;
 
@@ -818,6 +819,14 @@ var ClientAuthErrorMessage = {
     keyIdMissing: {
         code: "key_id_missing",
         desc: "A keyId value is missing from the requested bound token's cache record and is required to match the token to it's stored binding key."
+    },
+    noNetworkConnectivity: {
+        code: "no_network_connectivity",
+        desc: "No network connectivity. Check your internet connection."
+    },
+    userCanceledError: {
+        code: "user_canceled",
+        desc: "User canceled the flow."
     }
 };
 /**
@@ -1106,6 +1115,18 @@ var ClientAuthError = /** @class */ (function (_super) {
     ClientAuthError.createKeyIdMissingError = function () {
         return new ClientAuthError(ClientAuthErrorMessage.keyIdMissing.code, ClientAuthErrorMessage.keyIdMissing.desc);
     };
+    /**
+     * Create an error when the client does not have network connectivity
+     */
+    ClientAuthError.createNoNetworkConnectivityError = function () {
+        return new ClientAuthError(ClientAuthErrorMessage.noNetworkConnectivity.code, ClientAuthErrorMessage.noNetworkConnectivity.desc);
+    };
+    /**
+     * Create an error when the user cancels the flow
+     */
+    ClientAuthError.createUserCanceledError = function () {
+        return new ClientAuthError(ClientAuthErrorMessage.userCanceledError.code, ClientAuthErrorMessage.userCanceledError.desc);
+    };
     return ClientAuthError;
 }(AuthError));
 
@@ -1422,7 +1443,7 @@ var Logger = /** @class */ (function () {
 
 /* eslint-disable header/header */
 var name = "@azure/msal-common";
-var version = "10.0.0";
+var version = "11.0.0";
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -1610,8 +1631,11 @@ var CredentialEntity = /** @class */ (function () {
          */
         return (tokenType && tokenType.toLowerCase() !== exports.AuthenticationScheme.BEARER.toLowerCase()) ? tokenType.toLowerCase() : Constants.EMPTY_STRING;
     };
-    // Match host names like "login.microsoftonline.com", "https://accounts.google.com:4000", https://localhost:5000, etc.
-    CredentialEntity.credentialDomainRegex = "(https?:\\/\\/)?((([\\w-]+\\.)*([\\w-]{1,63})(\\.(\\w{2,63})))|(localhost))(\\:[0-9]{4,5})?";
+    /*
+     * Match host names like "login.microsoftonline.com", "https://accounts.google.com:4000", https://localhost:5000,
+     * "login.microsoftonline.com/common", "login.microsoftonline.com:4000/common", etc
+     */
+    CredentialEntity.credentialDomainRegex = "(https?:\\/\\/)?((([\\w-]+\\.)*([\\w-]{1,63})(\\.(\\w{2,63})))|(localhost))(\\:[0-9]{4,5})?(\\/[\\w-]+)?";
     return CredentialEntity;
 }());
 CredentialEntity._initRegex();
@@ -2889,7 +2913,7 @@ var CacheManager = /** @class */ (function () {
         else if (accounts.length > 1) {
             throw ClientAuthError.createMultipleMatchingAccountsInCacheError();
         }
-        return accountCache[0];
+        return accounts[0];
     };
     /**
      * Retrieve IdTokenEntity from cache
@@ -4907,6 +4931,7 @@ exports.PerformanceEvents = void 0;
      * Internal API for initializing silent request in SilentCacheClient (msal-browser)
      */
     PerformanceEvents["InitializeSilentRequest"] = "initializeSilentRequest";
+    PerformanceEvents["InitializeClientApplication"] = "initializeClientApplication";
     /**
      * Helper function in SilentIframeClient class (msal-browser).
      */
@@ -4972,6 +4997,7 @@ exports.PerformanceEvents = void 0;
     PerformanceEvents["HandleRedirectPromiseMeasurement"] = "handleRedirectPromiseMeasurement";
     PerformanceEvents["UpdateCloudDiscoveryMetadataMeasurement"] = "updateCloudDiscoveryMetadataMeasurement";
     PerformanceEvents["UsernamePasswordClientAcquireToken"] = "usernamePasswordClientAcquireToken";
+    PerformanceEvents["NativeMessageHandlerHandshake"] = "nativeMessageHandlerHandshake";
 })(exports.PerformanceEvents || (exports.PerformanceEvents = {}));
 /**
  * State of the performance event.
@@ -5337,7 +5363,7 @@ var ResponseHandler = /** @class */ (function () {
                         _b.sent();
                         _b.label = 7;
                     case 7: return [7 /*endfinally*/];
-                    case 8: return [2 /*return*/, ResponseHandler.generateAuthenticationResult(this.cryptoObj, authority, cacheRecord, false, request, idTokenObj, requestStateObj, serverTokenResponse.spa_code, serverRequestId)];
+                    case 8: return [2 /*return*/, ResponseHandler.generateAuthenticationResult(this.cryptoObj, authority, cacheRecord, false, request, idTokenObj, requestStateObj, serverTokenResponse, serverRequestId)];
                 }
             });
         });
@@ -5423,7 +5449,7 @@ var ResponseHandler = /** @class */ (function () {
      * @param fromTokenCache
      * @param stateString
      */
-    ResponseHandler.generateAuthenticationResult = function (cryptoObj, authority, cacheRecord, fromTokenCache, request, idTokenObj, requestState, code, requestId) {
+    ResponseHandler.generateAuthenticationResult = function (cryptoObj, authority, cacheRecord, fromTokenCache, request, idTokenObj, requestState, serverTokenResponse, requestId) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function () {
             var accessToken, responseScopes, expiresOn, extExpiresOn, familyId, popTokenGenerator, _d, secret, keyId, uid, tid;
@@ -5459,6 +5485,10 @@ var ResponseHandler = /** @class */ (function () {
                         }
                         uid = (idTokenObj === null || idTokenObj === void 0 ? void 0 : idTokenObj.claims.oid) || (idTokenObj === null || idTokenObj === void 0 ? void 0 : idTokenObj.claims.sub) || Constants.EMPTY_STRING;
                         tid = (idTokenObj === null || idTokenObj === void 0 ? void 0 : idTokenObj.claims.tid) || Constants.EMPTY_STRING;
+                        // for hybrid + native bridge enablement, send back the native account Id
+                        if ((serverTokenResponse === null || serverTokenResponse === void 0 ? void 0 : serverTokenResponse.spa_accountid) && !!cacheRecord.account) {
+                            cacheRecord.account.nativeAccountId = serverTokenResponse === null || serverTokenResponse === void 0 ? void 0 : serverTokenResponse.spa_accountid;
+                        }
                         return [2 /*return*/, {
                                 authority: authority.canonicalAuthority,
                                 uniqueId: uid,
@@ -5478,7 +5508,7 @@ var ResponseHandler = /** @class */ (function () {
                                 state: requestState ? requestState.userRequestState : Constants.EMPTY_STRING,
                                 cloudGraphHostName: ((_b = cacheRecord.account) === null || _b === void 0 ? void 0 : _b.cloudGraphHostName) || Constants.EMPTY_STRING,
                                 msGraphHost: ((_c = cacheRecord.account) === null || _c === void 0 ? void 0 : _c.msGraphHost) || Constants.EMPTY_STRING,
-                                code: code,
+                                code: serverTokenResponse === null || serverTokenResponse === void 0 ? void 0 : serverTokenResponse.spa_code,
                                 fromNativeBroker: false,
                             }];
                 }
@@ -8323,8 +8353,8 @@ var JoseHeader = /** @class */ (function () {
             throw JoseHeaderError.createMissingAlgError();
         }
         var shrHeader = new JoseHeader({
-            // Access Token PoP headers must have type JWT, but the type header can be overriden for special cases
-            typ: shrHeaderOptions.typ || JsonTypes.Jwt,
+            // Access Token PoP headers must have type pop, but the type header can be overriden for special cases
+            typ: shrHeaderOptions.typ || JsonTypes.Pop,
             kid: shrHeaderOptions.kid,
             alg: shrHeaderOptions.alg
         });
@@ -8575,11 +8605,8 @@ var PerformanceClient = /** @class */ (function () {
         this.logger = logger;
         this.callbacks = new Map();
         this.eventsByCorrelationId = new Map();
-        this.staticFieldsByCorrelationId = new Map();
-        this.measurementsById = new Map();
         this.queueMeasurements = new Map();
         this.preQueueTimeByCorrelationId = new Map();
-        this.countersByCorrelationId = new Map();
     }
     /**
      * Starts and returns an platform-specific implementation of IPerformanceMeasurement.
@@ -8620,16 +8647,16 @@ var PerformanceClient = /** @class */ (function () {
      * @returns {number}
      */
     PerformanceClient.prototype.getPreQueueTime = function (eventName, correlationId) {
-        var preQueueTimesByEvents = this.preQueueTimeByCorrelationId.get(correlationId);
-        if (!preQueueTimesByEvents) {
+        var preQueueEvent = this.preQueueTimeByCorrelationId.get(correlationId);
+        if (!preQueueEvent) {
             this.logger.trace("PerformanceClient.getPreQueueTime: no pre-queue times found for correlationId: " + correlationId + ", unable to add queue measurement");
             return;
         }
-        else if (!preQueueTimesByEvents.get(eventName)) {
+        else if (preQueueEvent.name !== eventName) {
             this.logger.trace("PerformanceClient.getPreQueueTime: no pre-queue time found for " + eventName + ", unable to add queue measurement");
             return;
         }
-        return preQueueTimesByEvents.get(eventName);
+        return preQueueEvent.time;
     };
     /**
      * Calculates the difference between current time and time when function was queued.
@@ -8657,12 +8684,13 @@ var PerformanceClient = /** @class */ (function () {
     /**
      * Adds queue measurement time to QueueMeasurements array for given correlation ID.
      *
-     * @param {PerformanceEvents} name
+     * @param {PerformanceEvents} eventName
      * @param {?string} correlationId
-     * @param {?number} time
+     * @param {?number} queueTime
+     * @param {?boolean} manuallyCompleted - indicator for manually completed queue measurements
      * @returns
      */
-    PerformanceClient.prototype.addQueueMeasurement = function (eventName, correlationId, queueTime) {
+    PerformanceClient.prototype.addQueueMeasurement = function (eventName, correlationId, queueTime, manuallyCompleted) {
         if (!correlationId) {
             this.logger.trace("PerformanceClient.addQueueMeasurement: correlationId not provided for " + eventName + ", cannot add queue measurement");
             return;
@@ -8675,7 +8703,7 @@ var PerformanceClient = /** @class */ (function () {
             this.logger.trace("PerformanceClient.addQueueMeasurement: no queue time provided for " + eventName);
             return;
         }
-        var queueMeasurement = { eventName: eventName, queueTime: queueTime };
+        var queueMeasurement = { eventName: eventName, queueTime: queueTime, manuallyCompleted: manuallyCompleted };
         // Adds to existing correlation Id if present in queueMeasurements
         var existingMeasurements = this.queueMeasurements.get(correlationId);
         if (existingMeasurements) {
@@ -8688,6 +8716,8 @@ var PerformanceClient = /** @class */ (function () {
             var measurementArray = [queueMeasurement];
             this.queueMeasurements.set(correlationId, measurementArray);
         }
+        // Delete processed pre-queue event.
+        this.preQueueTimeByCorrelationId.delete(correlationId);
     };
     /**
      * Starts measuring performance for a given operation. Returns a function that should be used to end the measurement.
@@ -8706,17 +8736,8 @@ var PerformanceClient = /** @class */ (function () {
         }
         // Duplicate code to address spelling error will be removed at the next major version bump.
         this.logger.trace("PerformanceClient: Performance measurement started for " + measureName, eventCorrelationId);
-        var validMeasurement;
-        var performanceMeasuremeant = this.startPerformanceMeasuremeant(measureName, eventCorrelationId);
-        if (performanceMeasuremeant.startMeasurement) {
-            performanceMeasuremeant.startMeasurement();
-            validMeasurement = performanceMeasuremeant;
-        }
-        else {
-            var performanceMeasurement = this.startPerformanceMeasurement(measureName, eventCorrelationId);
-            performanceMeasurement.startMeasurement();
-            validMeasurement = performanceMeasurement;
-        }
+        var performanceMeasurement = this.startPerformanceMeasuremeant(measureName, eventCorrelationId);
+        performanceMeasurement.startMeasurement();
         var inProgressEvent = {
             eventId: this.generateId(),
             status: exports.PerformanceEventStatus.InProgress,
@@ -8727,27 +8748,15 @@ var PerformanceClient = /** @class */ (function () {
             name: measureName,
             startTimeMs: Date.now(),
             correlationId: eventCorrelationId,
-        };
-        // Store in progress events so they can be discarded if not ended properly
-        this.cacheEventByCorrelationId(inProgressEvent);
-        var staticFields = {
             appName: (_a = this.applicationTelemetry) === null || _a === void 0 ? void 0 : _a.appName,
             appVersion: (_b = this.applicationTelemetry) === null || _b === void 0 ? void 0 : _b.appVersion,
         };
-        this.addStaticFields(staticFields, eventCorrelationId);
-        this.cacheMeasurement(inProgressEvent, validMeasurement);
+        // Store in progress events so they can be discarded if not ended properly
+        this.cacheEventByCorrelationId(inProgressEvent);
         // Return the event and functions the caller can use to properly end/flush the measurement
         return {
             endMeasurement: function (event) {
-                var completedEvent = _this.endMeasurement(__assign(__assign({}, inProgressEvent), event));
-                if (completedEvent) {
-                    // Cache event so that submeasurements can be added downstream
-                    _this.cacheEventByCorrelationId(completedEvent);
-                }
-                return completedEvent;
-            },
-            flushMeasurement: function () {
-                return _this.flushMeasurements(inProgressEvent.name, inProgressEvent.correlationId);
+                return _this.endMeasurement(__assign(__assign({}, inProgressEvent), event), performanceMeasurement);
             },
             discardMeasurement: function () {
                 return _this.discardMeasurements(inProgressEvent.correlationId);
@@ -8758,40 +8767,66 @@ var PerformanceClient = /** @class */ (function () {
             increment: function (counters) {
                 return _this.increment(counters, inProgressEvent.correlationId);
             },
-            measurement: validMeasurement,
+            measurement: performanceMeasurement,
             event: inProgressEvent
         };
     };
     /**
      * Stops measuring the performance for an operation. Should only be called directly by PerformanceClient classes,
      * as consumers should instead use the function returned by startMeasurement.
+     * Adds a new field named as "[event name]DurationMs" for sub-measurements, completes and emits an event
+     * otherwise.
      *
      * @param {PerformanceEvent} event
+     * @param {IPerformanceMeasurement} measurement
      * @returns {(PerformanceEvent | null)}
      */
-    PerformanceClient.prototype.endMeasurement = function (event) {
-        var performanceMeasurement = this.measurementsById.get(event.eventId);
-        if (performanceMeasurement) {
-            // Immediately delete so that the same event isnt ended twice
-            this.measurementsById.delete(event.eventId);
-            performanceMeasurement.endMeasurement();
-            var durationMs = performanceMeasurement.flushMeasurement();
-            // null indicates no measurement was taken (e.g. needed performance APIs not present)
-            if (durationMs !== null) {
-                this.logger.trace("PerformanceClient: Performance measurement ended for " + event.name + ": " + durationMs + " ms", event.correlationId);
-                var completedEvent = __assign(__assign({ 
-                    // Allow duration to be overwritten when event ends (e.g. testing), but not status
-                    durationMs: Math.round(durationMs) }, event), { status: exports.PerformanceEventStatus.Completed });
-                return completedEvent;
-            }
-            else {
-                this.logger.trace("PerformanceClient: Performance measurement not taken", event.correlationId);
-            }
+    PerformanceClient.prototype.endMeasurement = function (event, measurement) {
+        var _this = this;
+        var _a, _b;
+        var rootEvent = this.eventsByCorrelationId.get(event.correlationId);
+        if (!rootEvent) {
+            this.logger.trace("PerformanceClient: Measurement not found for " + event.eventId, event.correlationId);
+            return null;
+        }
+        var isRoot = event.eventId === rootEvent.eventId;
+        var queueInfo = {
+            totalQueueTime: 0,
+            totalQueueCount: 0,
+            manuallyCompletedCount: 0
+        };
+        if (isRoot) {
+            queueInfo = this.getQueueInfo(event.correlationId);
+            this.discardCache(rootEvent.correlationId);
         }
         else {
-            this.logger.trace("PerformanceClient: Measurement not found for " + event.eventId, event.correlationId);
+            (_a = rootEvent.incompleteSubMeasurements) === null || _a === void 0 ? void 0 : _a.delete(event.eventId);
         }
-        return null;
+        measurement === null || measurement === void 0 ? void 0 : measurement.endMeasurement();
+        var durationMs = measurement === null || measurement === void 0 ? void 0 : measurement.flushMeasurement();
+        // null indicates no measurement was taken (e.g. needed performance APIs not present)
+        if (!durationMs) {
+            this.logger.trace("PerformanceClient: Performance measurement not taken", rootEvent.correlationId);
+            return null;
+        }
+        this.logger.trace("PerformanceClient: Performance measurement ended for " + event.name + ": " + durationMs + " ms", event.correlationId);
+        // Add sub-measurement attribute to root event.
+        if (!isRoot) {
+            rootEvent[event.name + "DurationMs"] = Math.floor(durationMs);
+            return __assign({}, rootEvent);
+        }
+        var finalEvent = __assign(__assign({}, rootEvent), event);
+        var incompleteSubsCount = 0;
+        // Incomplete sub-measurements are discarded. They are likely an instrumentation bug that should be fixed.
+        (_b = finalEvent.incompleteSubMeasurements) === null || _b === void 0 ? void 0 : _b.forEach(function (subMeasurement) {
+            _this.logger.trace("PerformanceClient: Incomplete submeasurement " + subMeasurement.name + " found for " + event.name, finalEvent.correlationId);
+            incompleteSubsCount++;
+        });
+        finalEvent.incompleteSubMeasurements = undefined;
+        finalEvent = __assign(__assign({}, finalEvent), { durationMs: Math.round(durationMs), queuedTimeMs: queueInfo.totalQueueTime, queuedCount: queueInfo.totalQueueCount, queuedManuallyCompletedCount: queueInfo.manuallyCompletedCount, status: exports.PerformanceEventStatus.Completed, incompleteSubsCount: incompleteSubsCount });
+        this.truncateIntegralFields(finalEvent, this.getIntFields());
+        this.emitEvents([finalEvent], event.correlationId);
+        return finalEvent;
     };
     /**
      * Saves extra information to be emitted when the measurements are flushed
@@ -8799,14 +8834,13 @@ var PerformanceClient = /** @class */ (function () {
      * @param correlationId
      */
     PerformanceClient.prototype.addStaticFields = function (fields, correlationId) {
-        var existingStaticFields = this.staticFieldsByCorrelationId.get(correlationId);
-        if (existingStaticFields) {
-            this.logger.trace("PerformanceClient: Updating static fields");
-            this.staticFieldsByCorrelationId.set(correlationId, __assign(__assign({}, existingStaticFields), fields));
+        this.logger.trace("PerformanceClient: Updating static fields");
+        var event = this.eventsByCorrelationId.get(correlationId);
+        if (event) {
+            this.eventsByCorrelationId.set(correlationId, __assign(__assign({}, event), fields));
         }
         else {
-            this.logger.trace("PerformanceClient: Adding static fields");
-            this.staticFieldsByCorrelationId.set(correlationId, fields);
+            this.logger.trace("PerformanceClient: Event not found for", correlationId);
         }
     };
     /**
@@ -8815,18 +8849,18 @@ var PerformanceClient = /** @class */ (function () {
      * @param correlationId {string} correlation identifier
      */
     PerformanceClient.prototype.increment = function (counters, correlationId) {
-        var existing = this.countersByCorrelationId.get(correlationId);
-        if (!existing) {
-            this.logger.trace("PerformanceClient: Setting counters");
-            this.countersByCorrelationId.set(correlationId, __assign({}, counters));
-            return;
-        }
         this.logger.trace("PerformanceClient: Updating counters");
-        for (var counter in counters) {
-            if (!existing.hasOwnProperty(counter)) {
-                existing[counter] = 0;
+        var event = this.eventsByCorrelationId.get(correlationId);
+        if (event) {
+            for (var counter in counters) {
+                if (!event.hasOwnProperty(counter)) {
+                    event[counter] = 0;
+                }
+                event[counter] += counters[counter];
             }
-            existing[counter] += counters[counter];
+        }
+        else {
+            this.logger.trace("PerformanceClient: Event not found for", correlationId);
         }
     };
     /**
@@ -8839,117 +8873,35 @@ var PerformanceClient = /** @class */ (function () {
      * @param {PerformanceEvent} event
      */
     PerformanceClient.prototype.cacheEventByCorrelationId = function (event) {
-        var existingEvents = this.eventsByCorrelationId.get(event.correlationId);
-        if (existingEvents) {
+        var rootEvent = this.eventsByCorrelationId.get(event.correlationId);
+        if (rootEvent) {
             this.logger.trace("PerformanceClient: Performance measurement for " + event.name + " added/updated", event.correlationId);
-            existingEvents.set(event.eventId, event);
+            rootEvent.incompleteSubMeasurements = rootEvent.incompleteSubMeasurements || new Map();
+            rootEvent.incompleteSubMeasurements.set(event.eventId, { name: event.name, startTimeMs: event.startTimeMs });
         }
         else {
             this.logger.trace("PerformanceClient: Performance measurement for " + event.name + " started", event.correlationId);
-            this.eventsByCorrelationId.set(event.correlationId, new Map().set(event.eventId, event));
+            this.eventsByCorrelationId.set(event.correlationId, __assign({}, event));
         }
     };
-    /**
-     * Cache measurements by their id.
-     *
-     * @private
-     * @param {PerformanceEvent} event
-     * @param {IPerformanceMeasurement} measurement
-     */
-    PerformanceClient.prototype.cacheMeasurement = function (event, measurement) {
-        this.measurementsById.set(event.eventId, measurement);
-    };
-    /**
-     * Gathers and emits performance events for measurements taked for the given top-level API and correlation ID.
-     *
-     * @param {PerformanceEvents} measureName
-     * @param {string} correlationId
-     */
-    PerformanceClient.prototype.flushMeasurements = function (measureName, correlationId) {
-        var _this = this;
-        this.logger.trace("PerformanceClient: Performance measurements flushed for " + measureName, correlationId);
-        /**
-         * Adds all queue time and count measurements for given correlation ID
-         * then deletes queue times for given correlation ID from queueMeasurements map.
-         */
+    PerformanceClient.prototype.getQueueInfo = function (correlationId) {
         var queueMeasurementForCorrelationId = this.queueMeasurements.get(correlationId);
         if (!queueMeasurementForCorrelationId) {
             this.logger.trace("PerformanceClient: no queue measurements found for for correlationId: " + correlationId);
         }
         var totalQueueTime = 0;
         var totalQueueCount = 0;
+        var manuallyCompletedCount = 0;
         queueMeasurementForCorrelationId === null || queueMeasurementForCorrelationId === void 0 ? void 0 : queueMeasurementForCorrelationId.forEach(function (measurement) {
             totalQueueTime += measurement.queueTime;
             totalQueueCount++;
+            manuallyCompletedCount += measurement.manuallyCompleted ? 1 : 0;
         });
-        var eventsForCorrelationId = this.eventsByCorrelationId.get(correlationId);
-        var staticFields = this.staticFieldsByCorrelationId.get(correlationId);
-        var counters = this.countersByCorrelationId.get(correlationId);
-        if (eventsForCorrelationId) {
-            this.discardCache(correlationId);
-            /*
-             * Manually end incomplete submeasurements to ensure there arent orphaned/never ending events.
-             * Incomplete submeasurements are likely an instrumentation bug that should be fixed.
-             * IE only supports Map.forEach.
-             */
-            var completedEvents_1 = [];
-            var incompleteSubsCount_1 = 0;
-            eventsForCorrelationId.forEach(function (event) {
-                if (event.name !== measureName && event.status !== exports.PerformanceEventStatus.Completed) {
-                    _this.logger.trace("PerformanceClient: Incomplete submeasurement " + event.name + " found for " + measureName, correlationId);
-                    incompleteSubsCount_1++;
-                    var completedEvent = _this.endMeasurement(event);
-                    if (completedEvent) {
-                        completedEvents_1.push(completedEvent);
-                    }
-                }
-                completedEvents_1.push(event);
-            });
-            // Sort events by start time (earliest first)
-            var sortedCompletedEvents = completedEvents_1.sort(function (eventA, eventB) { return eventA.startTimeMs - eventB.startTimeMs; });
-            // Take completed top level event and add completed submeasurements durations as properties
-            var topLevelEvents = sortedCompletedEvents.filter(function (event) { return event.name === measureName && event.status === exports.PerformanceEventStatus.Completed; });
-            if (topLevelEvents.length > 0) {
-                /*
-                 * Only take the first top-level event if there are multiple events with the same correlation id.
-                 * This greatly simplifies logic for submeasurements.
-                 */
-                if (topLevelEvents.length > 1) {
-                    this.logger.verbose("PerformanceClient: Multiple distinct top-level performance events found, using the first", correlationId);
-                }
-                var topLevelEvent = topLevelEvents[0];
-                this.logger.verbose("PerformanceClient: Measurement found for " + measureName, correlationId);
-                // Build event object with top level and sub measurements
-                var eventToEmit = sortedCompletedEvents.reduce(function (previous, current) {
-                    if (current.name !== measureName) {
-                        _this.logger.trace("PerformanceClient: Complete submeasurement found for " + current.name, correlationId);
-                        // TODO: Emit additional properties for each subMeasurement
-                        var subMeasurementName = current.name + "DurationMs";
-                        /*
-                         * Some code paths, such as resolving an authority, can occur multiple times.
-                         * Only take the first measurement, since the second could be read from the cache,
-                         * or due to the same correlation id being used for two distinct requests.
-                         */
-                        if (!previous[subMeasurementName]) {
-                            previous[subMeasurementName] = current.durationMs;
-                        }
-                        else {
-                            _this.logger.verbose("PerformanceClient: Submeasurement for " + measureName + " already exists for " + current.name + ", ignoring", correlationId);
-                        }
-                    }
-                    return previous;
-                }, topLevelEvent);
-                var finalEvent = __assign(__assign(__assign(__assign({}, eventToEmit), staticFields), counters), { queuedTimeMs: totalQueueTime, queuedCount: totalQueueCount, incompleteSubsCount: incompleteSubsCount_1 });
-                this.truncateIntegralFields(finalEvent, this.getIntFields());
-                this.emitEvents([finalEvent], eventToEmit.correlationId);
-            }
-            else {
-                this.logger.verbose("PerformanceClient: No completed top-level measurements found for " + measureName, correlationId);
-            }
-        }
-        else {
-            this.logger.verbose("PerformanceClient: No measurements found", correlationId);
-        }
+        return {
+            totalQueueTime: totalQueueTime,
+            totalQueueCount: totalQueueCount,
+            manuallyCompletedCount: manuallyCompletedCount
+        };
     };
     /**
      * Removes measurements for a given correlation id.
@@ -8963,14 +8915,10 @@ var PerformanceClient = /** @class */ (function () {
     /**
      * Removes cache for a given correlation id.
      *
-     * @param {string} correlation identifier
+     * @param {string} correlationId correlation identifier
      */
     PerformanceClient.prototype.discardCache = function (correlationId) {
         this.discardMeasurements(correlationId);
-        this.logger.trace("PerformanceClient: Static fields discarded", correlationId);
-        this.staticFieldsByCorrelationId.delete(correlationId);
-        this.logger.trace("PerformanceClient: Counters discarded", correlationId);
-        this.countersByCorrelationId.delete(correlationId);
         this.logger.trace("PerformanceClient: QueueMeasurements discarded", correlationId);
         this.queueMeasurements.delete(correlationId);
         this.logger.trace("PerformanceClient: Pre-queue times discarded", correlationId);