@azure/msal-common 15.13.0 → 16.0.0-alpha.0

package/src/telemetry/performance/PerformanceClient.ts

@@ -9,39 +9,26 @@ import {
     InProgressPerformanceEvent,
     IPerformanceClient,
     PerformanceCallbackFunction,
-    QueueMeasurement,
 } from "./IPerformanceClient.js";
 import {
     IntFields,
     PerformanceEvent,
-    PerformanceEventAbbreviations,
     PerformanceEventContext,
-    PerformanceEvents,
     PerformanceEventStackedContext,
     PerformanceEventStatus,
 } from "./PerformanceEvent.js";
-import { IPerformanceMeasurement } from "./IPerformanceMeasurement.js";
-import { StubPerformanceMeasurement } from "./StubPerformanceClient.js";
 import { AuthError } from "../../error/AuthError.js";
 import { CacheError } from "../../error/CacheError.js";
 import { ServerError } from "../../error/ServerError.js";
 import { InteractionRequiredAuthError } from "../../error/InteractionRequiredAuthError.js";
-import { AccountInfo } from "../../account/AccountInfo.js";
-
-export interface PreQueueEvent {
-    name: PerformanceEvents;
-    time: number;
-}
 
 /**
  * Starts context by adding payload to the stack
  * @param event {PerformanceEvent}
- * @param abbreviations {Map<string, string>} event name abbreviations
  * @param stack {?PerformanceEventStackedContext[]} stack
  */
 export function startContext(
     event: PerformanceEvent,
-    abbreviations: Map<string, string>,
     stack?: PerformanceEventStackedContext[]
 ): void {
     if (!stack) {
@@ -49,7 +36,7 @@ export function startContext(
     }
 
     stack.push({
-        name: abbreviations.get(event.name) || event.name,
+        name: event.name,
     });
 }
 
@@ -57,13 +44,11 @@ export function startContext(
  * 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
  */
 export function endContext(
     event: PerformanceEvent,
-    abbreviations: Map<string, string>,
     stack?: PerformanceEventStackedContext[],
     error?: unknown
 ): PerformanceEventContext | undefined {
@@ -75,7 +60,7 @@ export function endContext(
         return stack.length ? stack[stack.length - 1] : undefined;
     };
 
-    const abbrEventName = abbreviations.get(event.name) || event.name;
+    const abbrEventName = event.name;
     const top = peek(stack);
     if (top?.name !== abbrEventName) {
         return;
@@ -265,22 +250,6 @@ export function compactStackLine(line: string): string {
     return line.trimStart();
 }
 
-export function getAccountType(
-    account?: AccountInfo
-): "AAD" | "MSA" | "B2C" | undefined {
-    const idTokenClaims = account?.idTokenClaims;
-    if (idTokenClaims?.tfp || idTokenClaims?.acr) {
-        return "B2C";
-    }
-
-    if (!idTokenClaims?.tid) {
-        return undefined;
-    } else if (idTokenClaims?.tid === "9188040d-6c67-4c5b-b112-36a304b66dad") {
-        return "MSA";
-    }
-    return "AAD";
-}
-
 export abstract class PerformanceClient implements IPerformanceClient {
     protected authority: string;
     protected libraryName: string;
@@ -297,22 +266,6 @@ export abstract class PerformanceClient implements IPerformanceClient {
      */
     protected eventsByCorrelationId: Map<string, PerformanceEvent>;
 
-    /**
-     * Map of pre-queue times by correlation Id
-     *
-     * @protected
-     * @type {Map<string, PreQueueEvent>}
-     */
-    protected preQueueTimeByCorrelationId: Map<string, PreQueueEvent>;
-
-    /**
-     * Map of queue measurements by correlation Id
-     *
-     * @protected
-     * @type {Map<string, Array<QueueMeasurement>>}
-     */
-    protected queueMeasurements: Map<string, Array<QueueMeasurement>>;
-
     protected intFields: Set<string>;
 
     /**
@@ -322,13 +275,6 @@ export abstract class PerformanceClient implements IPerformanceClient {
      */
     protected eventStack: Map<string, PerformanceEventStackedContext[]>;
 
-    /**
-     * Event name abbreviations
-     *
-     * @protected
-     */
-    protected abbreviations: Map<string, string>;
-
     /**
      * Creates an instance of PerformanceClient,
      * an abstract class containing core performance telemetry logic.
@@ -341,7 +287,6 @@ export abstract class PerformanceClient implements IPerformanceClient {
      * @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: string,
@@ -350,8 +295,7 @@ export abstract class PerformanceClient implements IPerformanceClient {
         libraryName: string,
         libraryVersion: string,
         applicationTelemetry: ApplicationTelemetry,
-        intFields?: Set<string>,
-        abbreviations?: Map<string, string>
+        intFields?: Set<string>
     ) {
         this.authority = authority;
         this.libraryName = libraryName;
@@ -362,16 +306,10 @@ export abstract class PerformanceClient implements IPerformanceClient {
         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);
-        }
     }
 
     /**
@@ -382,152 +320,6 @@ export abstract class PerformanceClient implements IPerformanceClient {
      */
     abstract generateId(): string;
 
-    /**
-     * Starts and returns an platform-specific implementation of IPerformanceMeasurement.
-     * Note: this function can be changed to abstract at the next major version bump.
-     *
-     * @param {string} measureName
-     * @param {string} correlationId
-     * @returns {IPerformanceMeasurement}
-     * @deprecated This method will be removed in the next major version
-     */
-    startPerformanceMeasurement(
-        measureName: string, // eslint-disable-line @typescript-eslint/no-unused-vars
-        correlationId: string // eslint-disable-line @typescript-eslint/no-unused-vars
-    ): IPerformanceMeasurement {
-        return {} as IPerformanceMeasurement;
-    }
-
-    /**
-     * Sets pre-queue time by correlation Id
-     *
-     * @abstract
-     * @param {PerformanceEvents} eventName
-     * @param {string} correlationId
-     * @returns
-     */
-    abstract setPreQueueTime(
-        eventName: PerformanceEvents,
-        correlationId?: string
-    ): void;
-
-    /**
-     * Gets map of pre-queue times by correlation Id
-     *
-     * @param {PerformanceEvents} eventName
-     * @param {string} correlationId
-     * @returns {number}
-     */
-    getPreQueueTime(eventName: string, correlationId: string): number | void {
-        const preQueueEvent: PreQueueEvent | undefined =
-            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 (preQueueEvent.name !== eventName) {
-            this.logger.trace(
-                `PerformanceClient.getPreQueueTime: no pre-queue time found for ${eventName}, unable to add queue measurement`
-            );
-            return;
-        }
-
-        return preQueueEvent.time;
-    }
-
-    /**
-     * Calculates the difference between current time and time when function was queued.
-     * Note: It is possible to have 0 as the queue time if the current time and the queued time was the same.
-     *
-     * @param {number} preQueueTime
-     * @param {number} currentTime
-     * @returns {number}
-     */
-    calculateQueuedTime(preQueueTime: number, currentTime: number): number {
-        if (preQueueTime < 1) {
-            this.logger.trace(
-                `PerformanceClient: preQueueTime should be a positive integer and not ${preQueueTime}`
-            );
-            return 0;
-        }
-
-        if (currentTime < 1) {
-            this.logger.trace(
-                `PerformanceClient: currentTime should be a positive integer and not ${currentTime}`
-            );
-            return 0;
-        }
-
-        if (currentTime < preQueueTime) {
-            this.logger.trace(
-                "PerformanceClient: currentTime is less than preQueueTime, check how time is being retrieved"
-            );
-            return 0;
-        }
-
-        return currentTime - preQueueTime;
-    }
-
-    /**
-     * Adds queue measurement time to QueueMeasurements array for given correlation ID.
-     *
-     * @param {PerformanceEvents} eventName
-     * @param {?string} correlationId
-     * @param {?number} queueTime
-     * @param {?boolean} manuallyCompleted - indicator for manually completed queue measurements
-     * @returns
-     */
-    addQueueMeasurement(
-        eventName: string,
-        correlationId?: string,
-        queueTime?: number,
-        manuallyCompleted?: boolean
-    ): void {
-        if (!correlationId) {
-            this.logger.trace(
-                `PerformanceClient.addQueueMeasurement: correlationId not provided for ${eventName}, cannot add queue measurement`
-            );
-            return;
-        }
-
-        if (queueTime === 0) {
-            // Possible for there to be no queue time after calculation
-            this.logger.trace(
-                `PerformanceClient.addQueueMeasurement: queue time provided for ${eventName} is ${queueTime}`
-            );
-        } else if (!queueTime) {
-            this.logger.trace(
-                `PerformanceClient.addQueueMeasurement: no queue time provided for ${eventName}`
-            );
-            return;
-        }
-
-        const queueMeasurement: QueueMeasurement = {
-            eventName,
-            // Always default queue time to 0 for manually completed (improperly instrumented)
-            queueTime: manuallyCompleted ? 0 : queueTime,
-            manuallyCompleted,
-        };
-
-        // Adds to existing correlation Id if present in queueMeasurements
-        const existingMeasurements = this.queueMeasurements.get(correlationId);
-        if (existingMeasurements) {
-            existingMeasurements.push(queueMeasurement);
-            this.queueMeasurements.set(correlationId, existingMeasurements);
-        } else {
-            // Sets new correlation Id if not present in queueMeasurements
-            this.logger.trace(
-                `PerformanceClient.addQueueMeasurement: adding correlationId ${correlationId} to queue measurements`
-            );
-            const 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.
      *
@@ -543,13 +335,13 @@ export abstract class PerformanceClient implements IPerformanceClient {
         const eventCorrelationId = correlationId || this.generateId();
         if (!correlationId) {
             this.logger.info(
-                `PerformanceClient: No correlation id provided for ${measureName}, generating`,
+                `PerformanceClient: No correlation id provided for '${measureName}', generating`,
                 eventCorrelationId
             );
         }
 
         this.logger.trace(
-            `PerformanceClient: Performance measurement started for ${measureName}`,
+            `PerformanceClient: Performance measurement started for '${measureName}'`,
             eventCorrelationId
         );
 
@@ -569,18 +361,13 @@ export abstract class PerformanceClient implements IPerformanceClient {
 
         // Store in progress events so they can be discarded if not ended properly
         this.cacheEventByCorrelationId(inProgressEvent);
-        startContext(
-            inProgressEvent,
-            this.abbreviations,
-            this.eventStack.get(eventCorrelationId)
-        );
+        startContext(inProgressEvent, this.eventStack.get(eventCorrelationId));
 
         // Return the event and functions the caller can use to properly end/flush the measurement
         return {
             end: (
                 event?: Partial<PerformanceEvent>,
-                error?: unknown,
-                account?: AccountInfo
+                error?: unknown
             ): PerformanceEvent | null => {
                 return this.endMeasurement(
                     {
@@ -589,8 +376,7 @@ export abstract class PerformanceClient implements IPerformanceClient {
                         // Properties set when event ends
                         ...event,
                     },
-                    error,
-                    account
+                    error
                 );
             },
             discard: () => {
@@ -606,7 +392,6 @@ export abstract class PerformanceClient implements IPerformanceClient {
                 );
             },
             event: inProgressEvent,
-            measurement: new StubPerformanceMeasurement(),
         };
     }
 
@@ -618,30 +403,23 @@ export abstract class PerformanceClient implements IPerformanceClient {
      *
      * @param {PerformanceEvent} event
      * @param {unknown} error
-     * @param {AccountInfo?} account
      * @returns {(PerformanceEvent | null)}
      */
     endMeasurement(
         event: PerformanceEvent,
-        error?: unknown,
-        account?: AccountInfo
+        error?: unknown
     ): PerformanceEvent | null {
         const rootEvent: PerformanceEvent | undefined =
             this.eventsByCorrelationId.get(event.correlationId);
         if (!rootEvent) {
             this.logger.trace(
-                `PerformanceClient: Measurement not found for ${event.eventId}`,
+                `PerformanceClient: Measurement not found for '${event.eventId}'`,
                 event.correlationId
             );
             return null;
         }
 
         const isRoot = event.eventId === rootEvent.eventId;
-        let queueInfo = {
-            totalQueueTime: 0,
-            totalQueueCount: 0,
-            manuallyCompletedCount: 0,
-        };
 
         event.durationMs = Math.round(
             event.durationMs || this.getDurationMs(event.startTimeMs)
@@ -650,21 +428,19 @@ export abstract class PerformanceClient implements IPerformanceClient {
         const context = JSON.stringify(
             endContext(
                 event,
-                this.abbreviations,
                 this.eventStack.get(rootEvent.correlationId),
                 error
             )
         );
 
         if (isRoot) {
-            queueInfo = this.getQueueInfo(event.correlationId);
             this.discardMeasurements(rootEvent.correlationId);
         } else {
             rootEvent.incompleteSubMeasurements?.delete(event.eventId);
         }
 
         this.logger.trace(
-            `PerformanceClient: Performance measurement ended for ${event.name}: ${event.durationMs} ms`,
+            `PerformanceClient: Performance measurement ended for '${event.name}': '${event.durationMs}' ms`,
             event.correlationId
         );
 
@@ -684,7 +460,7 @@ export abstract class PerformanceClient implements IPerformanceClient {
             (rootEvent.errorCode || rootEvent.subErrorCode)
         ) {
             this.logger.trace(
-                `PerformanceClient: Remove error and sub-error codes for root event ${event.name} as intermediate error was successfully handled`,
+                `PerformanceClient: Remove error and sub-error codes for root event '${event.name}' as intermediate error was successfully handled`,
                 event.correlationId
             );
             rootEvent.errorCode = undefined;
@@ -696,7 +472,7 @@ export abstract class PerformanceClient implements IPerformanceClient {
         // Incomplete sub-measurements are discarded. They are likely an instrumentation bug that should be fixed.
         finalEvent.incompleteSubMeasurements?.forEach((subMeasurement) => {
             this.logger.trace(
-                `PerformanceClient: Incomplete submeasurement ${subMeasurement.name} found for ${event.name}`,
+                `PerformanceClient: Incomplete submeasurement '${subMeasurement.name}' found for '${event.name}'`,
                 finalEvent.correlationId
             );
             incompleteSubsCount++;
@@ -705,18 +481,10 @@ export abstract class PerformanceClient implements IPerformanceClient {
 
         finalEvent = {
             ...finalEvent,
-            queuedTimeMs: queueInfo.totalQueueTime,
-            queuedCount: queueInfo.totalQueueCount,
-            queuedManuallyCompletedCount: queueInfo.manuallyCompletedCount,
             status: PerformanceEventStatus.Completed,
             incompleteSubsCount,
             context,
         };
-        if (account) {
-            finalEvent.accountType = getAccountType(account);
-            finalEvent.dataBoundary = account.dataBoundary;
-        }
-
         this.truncateIntegralFields(finalEvent);
         this.emitEvents([finalEvent], event.correlationId);
 
@@ -732,7 +500,10 @@ export abstract class PerformanceClient implements IPerformanceClient {
         fields: { [key: string]: {} | undefined },
         correlationId: string
     ): void {
-        this.logger.trace("PerformanceClient: Updating static fields");
+        this.logger.trace(
+            "PerformanceClient: Updating static fields",
+            correlationId
+        );
         const event = this.eventsByCorrelationId.get(correlationId);
         if (event) {
             this.eventsByCorrelationId.set(correlationId, {
@@ -756,7 +527,10 @@ export abstract class PerformanceClient implements IPerformanceClient {
         fields: { [key: string]: number | undefined },
         correlationId: string
     ): void {
-        this.logger.trace("PerformanceClient: Updating counters");
+        this.logger.trace(
+            "PerformanceClient: Updating counters",
+            correlationId
+        );
         const event = this.eventsByCorrelationId.get(correlationId);
         if (event) {
             for (const counter in fields) {
@@ -788,7 +562,7 @@ export abstract class PerformanceClient implements IPerformanceClient {
         const rootEvent = this.eventsByCorrelationId.get(event.correlationId);
         if (rootEvent) {
             this.logger.trace(
-                `PerformanceClient: Performance measurement for ${event.name} added/updated`,
+                `PerformanceClient: Performance measurement for '${event.name}' added/updated`,
                 event.correlationId
             );
             rootEvent.incompleteSubMeasurements =
@@ -799,7 +573,7 @@ export abstract class PerformanceClient implements IPerformanceClient {
             });
         } else {
             this.logger.trace(
-                `PerformanceClient: Performance measurement for ${event.name} started`,
+                `PerformanceClient: Performance measurement for '${event.name}' started`,
                 event.correlationId
             );
             this.eventsByCorrelationId.set(event.correlationId, { ...event });
@@ -807,35 +581,6 @@ export abstract class PerformanceClient implements IPerformanceClient {
         }
     }
 
-    private getQueueInfo(correlationId: string): {
-        totalQueueTime: number;
-        totalQueueCount: number;
-        manuallyCompletedCount: number;
-    } {
-        const queueMeasurementForCorrelationId =
-            this.queueMeasurements.get(correlationId);
-        if (!queueMeasurementForCorrelationId) {
-            this.logger.trace(
-                `PerformanceClient: no queue measurements found for for correlationId: ${correlationId}`
-            );
-        }
-
-        let totalQueueTime = 0;
-        let totalQueueCount = 0;
-        let manuallyCompletedCount = 0;
-        queueMeasurementForCorrelationId?.forEach((measurement) => {
-            totalQueueTime += measurement.queueTime;
-            totalQueueCount++;
-            manuallyCompletedCount += measurement.manuallyCompleted ? 1 : 0;
-        });
-
-        return {
-            totalQueueTime,
-            totalQueueCount,
-            manuallyCompletedCount,
-        };
-    }
-
     /**
      * Removes measurements and aux data for a given correlation id.
      *
@@ -848,18 +593,6 @@ export abstract class PerformanceClient implements IPerformanceClient {
         );
         this.eventsByCorrelationId.delete(correlationId);
 
-        this.logger.trace(
-            "PerformanceClient: QueueMeasurements discarded",
-            correlationId
-        );
-        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
@@ -877,7 +610,8 @@ export abstract class PerformanceClient implements IPerformanceClient {
         for (const [id, cb] of this.callbacks) {
             if (cb.toString() === callback.toString()) {
                 this.logger.warning(
-                    `PerformanceClient: Performance callback is already registered with id: ${id}`
+                    `PerformanceClient: Performance callback is already registered with id: ${id}`,
+                    ""
                 );
                 return id;
             }
@@ -886,7 +620,8 @@ export abstract class PerformanceClient implements IPerformanceClient {
         const callbackId = this.generateId();
         this.callbacks.set(callbackId, callback);
         this.logger.verbose(
-            `PerformanceClient: Performance callback registered with id: ${callbackId}`
+            `PerformanceClient: Performance callback registered with id: '${callbackId}'`,
+            ""
         );
 
         return callbackId;
@@ -903,11 +638,13 @@ export abstract class PerformanceClient implements IPerformanceClient {
 
         if (result) {
             this.logger.verbose(
-                `PerformanceClient: Performance callback ${callbackId} removed.`
+                `PerformanceClient: Performance callback '${callbackId}' removed.`,
+                ""
             );
         } else {
             this.logger.verbose(
-                `PerformanceClient: Performance callback ${callbackId} not removed.`
+                `PerformanceClient: Performance callback '${callbackId}' not removed.`,
+                ""
             );
         }
 
@@ -929,7 +666,7 @@ export abstract class PerformanceClient implements IPerformanceClient {
         this.callbacks.forEach(
             (callback: PerformanceCallbackFunction, callbackId: string) => {
                 this.logger.trace(
-                    `PerformanceClient: Emitting event to callback ${callbackId}`,
+                    `PerformanceClient: Emitting event to callback '${callbackId}'`,
                     correlationId
                 );
                 callback.apply(null, [events]);