plugin-data-source-mssql 2.0.5 → 2.0.7

package/dist/tedious/node_modules/@azure/msal-common/src/telemetry/performance/PerformanceClient.ts

@@ -4,44 +4,33 @@
  */
 
 import { ApplicationTelemetry } from "../../config/ClientConfiguration.js";
-import { Logger } from "../../logger/Logger.js";
+import { getAndFlushLogsFromCache, Logger } from "../../logger/Logger.js";
 import {
     InProgressPerformanceEvent,
     IPerformanceClient,
     PerformanceCallbackFunction,
-    QueueMeasurement,
 } from "./IPerformanceClient.js";
 import {
+    EXT_FIELD_PREFIX,
     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 +38,7 @@ export function startContext(
     }
 
     stack.push({
-        name: abbreviations.get(event.name) || event.name,
+        name: event.name,
     });
 }
 
@@ -57,13 +46,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 +62,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;
@@ -158,8 +145,10 @@ export function addError(
         event.errorCode = error.errorCode;
         event.subErrorCode = error.subError;
         if (
-            error instanceof ServerError ||
-            error instanceof InteractionRequiredAuthError
+            !event.serverErrorNo &&
+            (error instanceof ServerError ||
+                error instanceof InteractionRequiredAuthError) &&
+            error.errorNo
         ) {
             event.serverErrorNo = error.errorNo;
         }
@@ -297,22 +286,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 +295,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 +307,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 +315,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 +326,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 +340,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.
      *
@@ -541,17 +353,6 @@ export abstract class PerformanceClient implements IPerformanceClient {
     ): InProgressPerformanceEvent {
         // Generate a placeholder correlation if the request does not provide one
         const eventCorrelationId = correlationId || this.generateId();
-        if (!correlationId) {
-            this.logger.info(
-                `PerformanceClient: No correlation id provided for ${measureName}, generating`,
-                eventCorrelationId
-            );
-        }
-
-        this.logger.trace(
-            `PerformanceClient: Performance measurement started for ${measureName}`,
-            eventCorrelationId
-        );
 
         const inProgressEvent: PerformanceEvent = {
             eventId: this.generateId(),
@@ -569,11 +370,7 @@ 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 {
@@ -606,7 +403,6 @@ export abstract class PerformanceClient implements IPerformanceClient {
                 );
             },
             event: inProgressEvent,
-            measurement: new StubPerformanceMeasurement(),
         };
     }
 
@@ -630,18 +426,13 @@ export abstract class PerformanceClient implements IPerformanceClient {
             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,31 +441,30 @@ 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`,
-            event.correlationId
-        );
-
         if (error) {
             addError(error, this.logger, rootEvent);
         }
 
-        // Add sub-measurement attribute to root event.
+        // Add sub-measurement attribute to root event's ext field.
         if (!isRoot) {
-            rootEvent[event.name + "DurationMs"] = Math.floor(event.durationMs);
+            rootEvent.ext = {
+                ...rootEvent.ext,
+                ...event.ext,
+            };
+            rootEvent.ext[event.name + "DurationMs"] = Math.floor(
+                event.durationMs
+            );
             return { ...rootEvent };
         }
 
@@ -684,7 +474,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,21 +486,27 @@ 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++;
         });
         finalEvent.incompleteSubMeasurements = undefined;
 
+        const logs = getAndFlushLogsFromCache(event.correlationId);
+        // Format logs: [millis1,hash1;millis2,hash2;...]
+        const formattedLogs = logs
+            .map(
+                (logMessage) => `${logMessage.milliseconds},${logMessage.hash}`
+            )
+            .join(";");
+
         finalEvent = {
             ...finalEvent,
-            queuedTimeMs: queueInfo.totalQueueTime,
-            queuedCount: queueInfo.totalQueueCount,
-            queuedManuallyCompletedCount: queueInfo.manuallyCompletedCount,
             status: PerformanceEventStatus.Completed,
             incompleteSubsCount,
             context,
+            logs: formattedLogs,
         };
         if (account) {
             finalEvent.accountType = getAccountType(account);
@@ -732,13 +528,38 @@ export abstract class PerformanceClient implements IPerformanceClient {
         fields: { [key: string]: {} | undefined },
         correlationId: string
     ): void {
-        this.logger.trace("PerformanceClient: Updating static fields");
         const event = this.eventsByCorrelationId.get(correlationId);
         if (event) {
-            this.eventsByCorrelationId.set(correlationId, {
+            const staticFields: { [key: string]: {} | undefined } = {};
+            const dynamicFields: Record<string, string | number> = {};
+
+            for (const key in fields) {
+                if (key.startsWith(EXT_FIELD_PREFIX)) {
+                    const dynamicKey = key.slice(EXT_FIELD_PREFIX.length);
+                    const value = fields[key];
+                    if (
+                        typeof value === "string" ||
+                        typeof value === "number"
+                    ) {
+                        dynamicFields[dynamicKey] = value;
+                    }
+                } else {
+                    staticFields[key] = fields[key];
+                }
+            }
+
+            const updatedEvent: PerformanceEvent = {
                 ...event,
-                ...fields,
-            });
+                ...staticFields,
+            };
+            if (Object.keys(dynamicFields).length) {
+                updatedEvent.ext = {
+                    ...updatedEvent.ext,
+                    ...dynamicFields,
+                };
+            }
+
+            this.eventsByCorrelationId.set(correlationId, updatedEvent);
         } else {
             this.logger.trace(
                 "PerformanceClient: Event not found for",
@@ -756,16 +577,32 @@ export abstract class PerformanceClient implements IPerformanceClient {
         fields: { [key: string]: number | undefined },
         correlationId: string
     ): void {
-        this.logger.trace("PerformanceClient: Updating counters");
         const event = this.eventsByCorrelationId.get(correlationId);
         if (event) {
             for (const counter in fields) {
-                if (!event.hasOwnProperty(counter)) {
-                    event[counter] = 0;
-                } else if (isNaN(Number(event[counter]))) {
-                    return;
+                if (counter.startsWith(EXT_FIELD_PREFIX)) {
+                    event.ext = event.ext || {};
+                    // Route to ext sub-object
+                    const dynamicKey = counter.slice(EXT_FIELD_PREFIX.length);
+                    const currentValue = event.ext[dynamicKey];
+                    if (currentValue === undefined) {
+                        event.ext[dynamicKey] = 0;
+                    } else if (isNaN(Number(currentValue))) {
+                        return;
+                    }
+                    event.ext[dynamicKey] =
+                        (Number(event.ext[dynamicKey]) || 0) +
+                        (fields[counter] ?? 0);
+                } else {
+                    /* eslint-disable custom-msal/no-dynamic-telemetry-fields -- internal dispatching of static fields by name */
+                    if (!event.hasOwnProperty(counter)) {
+                        event[counter] = 0;
+                    } else if (isNaN(Number(event[counter]))) {
+                        return;
+                    }
+                    event[counter] += fields[counter];
+                    /* eslint-enable custom-msal/no-dynamic-telemetry-fields */
                 }
-                event[counter] += fields[counter];
             }
         } else {
             this.logger.trace(
@@ -787,10 +624,6 @@ export abstract class PerformanceClient implements IPerformanceClient {
     protected cacheEventByCorrelationId(event: PerformanceEvent): void {
         const rootEvent = this.eventsByCorrelationId.get(event.correlationId);
         if (rootEvent) {
-            this.logger.trace(
-                `PerformanceClient: Performance measurement for ${event.name} added/updated`,
-                event.correlationId
-            );
             rootEvent.incompleteSubMeasurements =
                 rootEvent.incompleteSubMeasurements || new Map();
             rootEvent.incompleteSubMeasurements.set(event.eventId, {
@@ -798,72 +631,18 @@ export abstract class PerformanceClient implements IPerformanceClient {
                 startTimeMs: event.startTimeMs,
             });
         } else {
-            this.logger.trace(
-                `PerformanceClient: Performance measurement for ${event.name} started`,
-                event.correlationId
-            );
             this.eventsByCorrelationId.set(event.correlationId, { ...event });
             this.eventStack.set(event.correlationId, []);
         }
     }
 
-    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.
      *
      * @param {string} correlationId
      */
     discardMeasurements(correlationId: string): void {
-        this.logger.trace(
-            "PerformanceClient: Performance measurements discarded",
-            correlationId
-        );
         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
-        );
         this.eventStack.delete(correlationId);
     }
 
@@ -877,7 +656,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 +666,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 +684,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 +712,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]);
@@ -943,9 +726,11 @@ export abstract class PerformanceClient implements IPerformanceClient {
      */
     private truncateIntegralFields(event: PerformanceEvent): void {
         this.intFields.forEach((key) => {
+            /* eslint-disable custom-msal/no-dynamic-telemetry-fields -- internal truncation of known integer fields */
             if (key in event && typeof event[key] === "number") {
                 event[key] = Math.floor(event[key]);
             }
+            /* eslint-enable custom-msal/no-dynamic-telemetry-fields */
         });
     }