@fluidframework/telemetry-utils 2.0.0-rc.4.0.6 → 2.0.0-rc.5.0.1

package/src/mockLogger.ts

@@ -4,36 +4,74 @@
  */
 
 import {
-	ITelemetryBaseEvent,
-	ITelemetryBaseLogger,
+	type ITelemetryBaseEvent,
+	type ITelemetryBaseLogger,
 	LogLevel,
 } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 
 import { createChildLogger } from "./logger.js";
-import { ITelemetryLoggerExt, ITelemetryPropertiesExt } from "./telemetryTypes.js";
+import type {
+	ITelemetryEventExt,
+	ITelemetryLoggerExt,
+	ITelemetryPropertiesExt,
+} from "./telemetryTypes.js";
 
 /**
- * The MockLogger records events sent to it, and then can walk back over those events
- * searching for a set of expected events to match against the logged events.
+ * Mock {@link @fluidframework/core-interfaces#ITelemetryBaseLogger} implementation.
+ *
+ * Records events sent to it, and then can walk back over those events, searching for a set of expected events to
+ * match against the logged events.
+ *
+ * @deprecated
+ *
+ * This class is not intended for use outside of the `fluid-framework` repo, and will be removed from
+ * package exports in the near future.
+ *
+ * Please migrate usages by either creating your own mock {@link @fluidframework/core-interfaces#ITelemetryBaseLogger}
+ * implementation, or by copying this code as-is into your own repo.
+ *
+ * @privateRemarks TODO: When we are ready, this type should be made `internal`, and the deprecation notice should be removed.
  *
  * @alpha
  */
 export class MockLogger implements ITelemetryBaseLogger {
-	events: ITelemetryBaseEvent[] = [];
+	/**
+	 * Gets an immutable copy of the events logged thus far.
+	 */
+	public get events(): readonly ITelemetryBaseEvent[] {
+		return [...this._events];
+	}
+
+	private _events: ITelemetryBaseEvent[] = [];
 
-	constructor(public readonly minLogLevel?: LogLevel) {}
+	/**
+	 * {@inheritDoc @fluidframework/core-interfaces#ITelemetryBaseLogger.minLogLevel}
+	 */
+	public readonly minLogLevel: LogLevel;
 
-	clear(): void {
-		this.events = [];
+	public constructor(minLogLevel?: LogLevel) {
+		this.minLogLevel = minLogLevel ?? LogLevel.default;
 	}
 
-	toTelemetryLogger(): ITelemetryLoggerExt {
+	/**
+	 * Clears the events logged thus far.
+	 */
+	public clear(): void {
+		this._events = [];
+	}
+
+	public toTelemetryLogger(): ITelemetryLoggerExt {
 		return createChildLogger({ logger: this });
 	}
 
-	send(event: ITelemetryBaseEvent): void {
-		this.events.push(event);
+	/**
+	 * {@inheritDoc @fluidframework/core-interfaces#ITelemetryBaseLogger.send}
+	 */
+	public send(event: ITelemetryBaseEvent, logLevel?: LogLevel): void {
+		if (logLevel ?? LogLevel.default >= this.minLogLevel) {
+			this._events.push(event);
+		}
 	}
 
 	/**
@@ -43,14 +81,18 @@ export class MockLogger implements ITelemetryBaseLogger {
 	 * @param inlineDetailsProp - true if the "details" property in the actual event should be extracted and inlined.
 	 * These event objects may be subsets of the logged events.
 	 * Note: category is omitted from the type because it's usually uninteresting and tedious to type.
+	 * @param clearEventsAfterCheck - Whether or not to clear the logger's {@link MockLogger.events} after performing the check.
+	 * Default: true.
 	 */
-	matchEvents(
+	public matchEvents(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		inlineDetailsProp: boolean = false,
+		clearEventsAfterCheck: boolean = true,
 	): boolean {
 		const matchedExpectedEventCount = this.getMatchedEventsCount(
 			expectedEvents,
 			inlineDetailsProp,
+			clearEventsAfterCheck,
 		);
 		// How many expected events were left over? Hopefully none.
 		const unmatchedExpectedEventCount = expectedEvents.length - matchedExpectedEventCount;
@@ -58,15 +100,26 @@ export class MockLogger implements ITelemetryBaseLogger {
 	}
 
 	/**
-	 * Asserts that matchEvents is true, and prints the actual/expected output if not.
+	 * Asserts {@link MockLogger.matchEvents} is `true` for the given events.
+	 * @param expectedEvents - The events expected to appear.
+	 * @param message - Optional error message to include in the thrown error, if the condition is not satisfied.
+	 * @param inlineDetailsProp - true if the "details" property in the actual event should be extracted and inlined.
+	 * These event objects may be subsets of the logged events.
+	 * Note: category is omitted from the type because it's usually uninteresting and tedious to type.
+	 * @param clearEventsAfterCheck - Whether or not to clear the logger's {@link MockLogger.events} after performing the check.
+	 * Default: true.
+	 * @throws An error containing the actual/expected event data if the condition is not satisfied.
 	 */
-	assertMatch(
+	public assertMatch(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
+		clearEventsAfterCheck: boolean = true,
 	): void {
+		// Use copy to ensure events aren't cleared out from under us before we (potentially) throw
 		const actualEvents = this.events;
-		if (!this.matchEvents(expectedEvents, inlineDetailsProp)) {
+
+		if (!this.matchEvents(expectedEvents, inlineDetailsProp, clearEventsAfterCheck)) {
 			throw new Error(`${message ?? "Logs don't match"}
 expected:
 ${JSON.stringify(expectedEvents)}
@@ -85,27 +138,40 @@ ${JSON.stringify(actualEvents)}`);
 	 * Note: category is omitted from the type because it's usually uninteresting and tedious to type.
 	 * @returns if any of the expected events is found.
 	 */
-	matchAnyEvent(
+	public matchAnyEvent(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		inlineDetailsProp: boolean = false,
+		clearEventsAfterCheck: boolean = true,
 	): boolean {
 		const matchedExpectedEventCount = this.getMatchedEventsCount(
 			expectedEvents,
 			inlineDetailsProp,
+			clearEventsAfterCheck,
 		);
 		return matchedExpectedEventCount > 0;
 	}
 
 	/**
-	 * Asserts that matchAnyEvent is true, and prints the actual/expected output if not.
+	 * Asserts {@link MockLogger.matchAnyEvent} is `true` for the given events.
+	 * @param expectedEvents - The events expected to appear.
+	 * @param message - Optional error message to include in the thrown error, if the condition is not satisfied.
+	 * @param inlineDetailsProp - true if the "details" property in the actual event should be extracted and inlined.
+	 * These event objects may be subsets of the logged events.
+	 * Note: category is omitted from the type because it's usually uninteresting and tedious to type.
+	 * @param clearEventsAfterCheck - Whether or not to clear the logger's {@link MockLogger.events} after performing the check.
+	 * Default: true.
+	 * @throws An error containing the actual/expected event data if the condition is not satisfied.
 	 */
-	assertMatchAny(
+	public assertMatchAny(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
+		clearEventsAfterCheck: boolean = true,
 	): void {
+		// Use copy to ensure events aren't cleared out from under us before we (potentially) throw
 		const actualEvents = this.events;
-		if (!this.matchAnyEvent(expectedEvents, inlineDetailsProp)) {
+
+		if (!this.matchAnyEvent(expectedEvents, inlineDetailsProp, clearEventsAfterCheck)) {
 			throw new Error(`${message ?? "Logs don't match"}
 expected:
 ${JSON.stringify(expectedEvents)}
@@ -122,27 +188,46 @@ ${JSON.stringify(actualEvents)}`);
 	 * @param inlineDetailsProp - true if the "details" property in the actual event should be extracted and inlined.
 	 * These event objects may be subsets of the logged events.
 	 * Note: category is omitted from the type because it's usually uninteresting and tedious to type.
+	 * @param clearEventsAfterCheck - Whether or not to clear the logger's {@link MockLogger.events} after performing the check.
+	 * Default: true.
 	 */
-	matchEventStrict(
+	public matchEventStrict(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		inlineDetailsProp: boolean = false,
+		clearEventsAfterCheck: boolean = true,
 	): boolean {
-		return (
-			expectedEvents.length === this.events.length &&
-			this.matchEvents(expectedEvents, inlineDetailsProp)
-		);
+		if (expectedEvents.length !== this._events.length) {
+			if (clearEventsAfterCheck) {
+				this.clear();
+			}
+			return false;
+		}
+
+		// `events` will be cleared by the below check if requested.
+		return this.matchEvents(expectedEvents, inlineDetailsProp, clearEventsAfterCheck);
 	}
 
 	/**
-	 * Asserts that matchEvents is true, and prints the actual/expected output if not
+	 * Asserts {@link MockLogger.matchEvents} is `true` for the given events.
+	 * @param expectedEvents - The events expected to appear.
+	 * @param message - Optional error message to include in the thrown error, if the condition is not satisfied.
+	 * @param inlineDetailsProp - true if the "details" property in the actual event should be extracted and inlined.
+	 * These event objects may be subsets of the logged events.
+	 * Note: category is omitted from the type because it's usually uninteresting and tedious to type.
+	 * @param clearEventsAfterCheck - Whether or not to clear the logger's {@link MockLogger.events} after performing the check.
+	 * Default: true.
+	 * @throws An error containing the actual/expected event data if the condition is not satisfied.
 	 */
-	assertMatchStrict(
+	public assertMatchStrict(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
+		clearEventsAfterCheck: boolean = true,
 	): void {
+		// Use copy to ensure events aren't cleared out from under us before we (potentially) throw
 		const actualEvents = this.events;
-		if (!this.matchEventStrict(expectedEvents, inlineDetailsProp)) {
+
+		if (!this.matchEventStrict(expectedEvents, inlineDetailsProp, clearEventsAfterCheck)) {
 			throw new Error(`${message ?? "Logs don't match"}
 expected:
 ${JSON.stringify(expectedEvents)}
@@ -153,15 +238,26 @@ ${JSON.stringify(actualEvents)}`);
 	}
 
 	/**
-	 * Asserts that matchAnyEvent is false for the given events, and prints the actual/expected output if not
+	 * Asserts {@link MockLogger.matchAnyEvent} is `false` for the given events.
+	 * @param disallowedEvents - The events expected to not appear.
+	 * @param message - Optional error message to include in the thrown error, if the condition is not satisfied.
+	 * @param inlineDetailsProp - true if the "details" property in the actual event should be extracted and inlined.
+	 * These event objects may be subsets of the logged events.
+	 * Note: category is omitted from the type because it's usually uninteresting and tedious to type.
+	 * @param clearEventsAfterCheck - Whether or not to clear the logger's {@link MockLogger.events} after performing the check.
+	 * Default: true.
+	 * @throws An error containing the actual/expected event data if the condition is not satisfied.
 	 */
-	assertMatchNone(
+	public assertMatchNone(
 		disallowedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
+		clearEventsAfterCheck: boolean = true,
 	): void {
+		// Use copy to ensure events aren't cleared out from under us before we (potentially) throw
 		const actualEvents = this.events;
-		if (this.matchAnyEvent(disallowedEvents, inlineDetailsProp)) {
+
+		if (this.matchAnyEvent(disallowedEvents, inlineDetailsProp, clearEventsAfterCheck)) {
 			throw new Error(`${message ?? "Logs don't match"}
 disallowed events:
 ${JSON.stringify(disallowedEvents)}
@@ -174,9 +270,10 @@ ${JSON.stringify(actualEvents)}`);
 	private getMatchedEventsCount(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		inlineDetailsProp: boolean,
+		clearEventsAfterCheck: boolean,
 	): number {
 		let iExpectedEvent = 0;
-		for (const event of this.events) {
+		for (const event of this._events) {
 			if (
 				iExpectedEvent < expectedEvents.length &&
 				MockLogger.eventsMatch(event, expectedEvents[iExpectedEvent], inlineDetailsProp)
@@ -187,7 +284,9 @@ ${JSON.stringify(actualEvents)}`);
 		}
 
 		// Remove the events so far; next call will just compare subsequent events from here
-		this.events = [];
+		if (clearEventsAfterCheck) {
+			this.clear();
+		}
 
 		// Return the count of matched events.
 		return iExpectedEvent;
@@ -208,7 +307,6 @@ ${JSON.stringify(actualEvents)}`);
 		if (inlineDetailsProp && details !== undefined) {
 			assert(
 				typeof details === "string",
-				// eslint-disable-next-line unicorn/numeric-separators-style
 				0x6c9 /* Details should a JSON stringified string if inlineDetailsProp is true */,
 			);
 			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
@@ -220,7 +318,10 @@ ${JSON.stringify(actualEvents)}`);
 	}
 }
 
-function matchObjects(actual: ITelemetryPropertiesExt, expected: ITelemetryPropertiesExt): boolean {
+function matchObjects(
+	actual: ITelemetryPropertiesExt,
+	expected: ITelemetryPropertiesExt,
+): boolean {
 	for (const [expectedKey, expectedValue] of Object.entries(expected)) {
 		const actualValue = actual[expectedKey];
 		if (
@@ -245,3 +346,32 @@ function matchObjects(actual: ITelemetryPropertiesExt, expected: ITelemetryPrope
 	}
 	return true;
 }
+
+/**
+ * Mock {@link ITelemetryLoggerExt} implementation.
+ *
+ * @remarks Can be created via {@link createMockLoggerExt}.
+ *
+ * @internal
+ */
+export interface IMockLoggerExt extends ITelemetryLoggerExt {
+	/**
+	 * Gets the events that have been logged so far.
+	 */
+	events(): readonly ITelemetryEventExt[];
+}
+
+/**
+ * Creates an {@link IMockLoggerExt}.
+ *
+ * @internal
+ */
+export function createMockLoggerExt(minLogLevel?: LogLevel): IMockLoggerExt {
+	const mockLogger = new MockLogger(minLogLevel);
+	const childLogger = createChildLogger({ logger: mockLogger });
+	Object.assign(childLogger, {
+		events: (): readonly ITelemetryEventExt[] =>
+			mockLogger.events.map((e) => e as ITelemetryEventExt),
+	});
+	return childLogger as IMockLoggerExt;
+}

package/src/sampledTelemetryHelper.ts

@@ -6,10 +6,10 @@
 import { performance } from "@fluid-internal/client-utils";
 import type { IDisposable, ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
 
-import {
-	type ITelemetryGenericEventExt,
+import type {
+	ITelemetryGenericEventExt,
 	ITelemetryLoggerExt,
-	type ITelemetryPerformanceEventExt,
+	ITelemetryPerformanceEventExt,
 } from "./telemetryTypes.js";
 
 /**
@@ -58,7 +58,14 @@ interface Measurements {
  * @internal
  */
 export class SampledTelemetryHelper implements IDisposable {
-	disposed: boolean = false;
+	private _disposed: boolean = false;
+
+	/**
+	 * {@inheritDoc @fluidframework/core-interfaces#IDisposable.disposed}
+	 */
+	public get disposed(): boolean {
+		return this._disposed;
+	}
 
 	private readonly measurementsMap = new Map<string, Measurements>();
 
@@ -145,6 +152,9 @@ export class SampledTelemetryHelper implements IDisposable {
 	}
 
 	public dispose(error?: Error | undefined): void {
-		for (const [k] of this.measurementsMap.entries()) this.flushBucket(k);
+		for (const [k] of this.measurementsMap.entries()) {
+			this.flushBucket(k);
+		}
+		this._disposed = true;
 	}
 }

package/src/telemetryEventBatcher.ts

@@ -0,0 +1,103 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { roundToDecimalPlaces } from "./mathTools.js";
+import type {
+	ITelemetryGenericEventExt,
+	ITelemetryLoggerExt,
+	ITelemetryPerformanceEventExt,
+} from "./telemetryTypes.js";
+
+/**
+ * Telemetry class that accumulates measurements which are eventually logged in a telemetry event through the provided
+ * {@link TelemetryEventBatcher.logger | logger} when the number of calls to the function reaches the specified {@link TelemetryEventBatcher.threshold | threshold}.
+ *
+ * @remarks It is expected to be used for a single event type. If different properties should be logged at different times, a separate `TelemetryEventBatcher` should be created with separate `TMetrics` type.
+ * @typeparam TMetrics - The set of keys that should be logged.
+ * E.g., `keyof Foo` for logging properties `bar` and `baz` from `type Foo = { bar: number, baz: number }`.
+ *
+ * @sealed
+ * @internal
+ */
+export class TelemetryEventBatcher<TMetrics extends string> {
+	/**
+	 * Stores the sum of the custom data passed into the logger.
+	 */
+	private dataSums: { [key in TMetrics]?: number } = {};
+
+	/**
+	 * Stores the maximum value of the custom data passed into the logger.
+	 */
+	private dataMaxes: { [key in TMetrics]?: number } = {};
+
+	/**
+	 * Counter to keep track of the number of times the log function is called.
+	 */
+	private counter = 0;
+
+	public constructor(
+		/**
+		 * Custom properties to include in the telemetry performance event when it is written.
+		 */
+		private readonly eventBase: ITelemetryGenericEventExt,
+
+		/**
+		 * The logger to use to write the telemetry performance event.
+		 */
+		private readonly logger: ITelemetryLoggerExt,
+
+		/**
+		 * The number of logs to accumulate before sending the data to the logger.
+		 */
+		private readonly threshold: number,
+	) {}
+
+	/**
+	 * Accumulates the custom data and sends it to the logger every {@link TelemetryEventBatcher.threshold} calls.
+	 *
+	 * @param customData -
+	 * A record storing the custom data to be accumulated and eventually logged.
+	 */
+	public accumulateAndLog(customData: Record<TMetrics, number>): void {
+		for (const key of Object.keys(customData) as TMetrics[]) {
+			this.dataSums[key] = (this.dataSums[key] ?? 0) + customData[key];
+			this.dataMaxes[key] = Math.max(
+				this.dataMaxes[key] ?? Number.NEGATIVE_INFINITY,
+				customData[key],
+			);
+		}
+
+		this.counter++;
+
+		if (this.counter >= this.threshold) {
+			this.sendData();
+		}
+	}
+
+	private sendData(): void {
+		const telemetryEvent: ITelemetryPerformanceEventExt = {
+			...this.eventBase,
+		};
+
+		for (const key of Object.keys(this.dataSums) as TMetrics[]) {
+			if (this.dataSums[key] !== undefined) {
+				telemetryEvent[`avg_${key}`] = roundToDecimalPlaces(
+					this.dataSums[key]! / this.counter,
+					6,
+				);
+			}
+			if (this.dataMaxes[key] !== undefined) {
+				telemetryEvent[`max_${key}`] = this.dataMaxes[key];
+			}
+		}
+
+		this.logger.sendPerformanceEvent(telemetryEvent);
+
+		// Reset the counter and the data.
+		this.counter = 0;
+		this.dataSums = {};
+		this.dataMaxes = {};
+	}
+}

package/src/telemetryTypes.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryBaseLogger, LogLevel, Tagged } from "@fluidframework/core-interfaces";
+import type { ITelemetryBaseLogger, LogLevel, Tagged } from "@fluidframework/core-interfaces";
 
 /**
  * The categories FF uses when instrumenting the code.
@@ -31,10 +31,7 @@ export type TelemetryEventPropertyTypeExt =
 	| boolean
 	| undefined
 	| (string | number | boolean)[]
-	| {
-			[key: string]: // Flat objects can have the same properties as the event itself
-			string | number | boolean | undefined | (string | number | boolean)[];
-	  };
+	| Record<string, string | number | boolean | undefined | (string | number | boolean)[]>;
 
 /**
  * A property to be logged to telemetry containing both the value and a tag. Tags are generic strings that can be used
@@ -53,9 +50,10 @@ export interface ITaggedTelemetryPropertyTypeExt {
  * JSON-serializable properties, which will be logged with telemetry.
  * @alpha
  */
-export interface ITelemetryPropertiesExt {
-	[index: string]: TelemetryEventPropertyTypeExt | Tagged<TelemetryEventPropertyTypeExt>;
-}
+export type ITelemetryPropertiesExt = Record<
+	string,
+	TelemetryEventPropertyTypeExt | Tagged<TelemetryEventPropertyTypeExt>
+>;
 
 /**
  * Interface for logging telemetry statements.
@@ -66,7 +64,14 @@ export interface ITelemetryPropertiesExt {
  * @internal
  */
 export interface ITelemetryEventExt extends ITelemetryPropertiesExt {
+	/**
+	 * {@inheritDoc @fluidframework/core-interfaces#ITelemetryBaseEvent.category}
+	 */
 	category: string;
+
+	/**
+	 * {@inheritDoc @fluidframework/core-interfaces#ITelemetryBaseEvent.eventName}
+	 */
 	eventName: string;
 }
 
@@ -76,7 +81,15 @@ export interface ITelemetryEventExt extends ITelemetryPropertiesExt {
  * @alpha
  */
 export interface ITelemetryGenericEventExt extends ITelemetryPropertiesExt {
+	/**
+	 * {@inheritDoc @fluidframework/core-interfaces#ITelemetryBaseEvent.eventName}
+	 */
 	eventName: string;
+
+	/**
+	 * Optional event {@link @fluidframework/core-interfaces#ITelemetryBaseEvent.category}.
+	 * @defaultValue "generic"
+	 */
 	category?: TelemetryEventCategory;
 }
 
@@ -86,6 +99,9 @@ export interface ITelemetryGenericEventExt extends ITelemetryPropertiesExt {
  * @alpha
  */
 export interface ITelemetryErrorEventExt extends ITelemetryPropertiesExt {
+	/**
+	 * {@inheritDoc @fluidframework/core-interfaces#ITelemetryBaseEvent.eventName}
+	 */
 	eventName: string;
 }
 
@@ -95,7 +111,10 @@ export interface ITelemetryErrorEventExt extends ITelemetryPropertiesExt {
  * @alpha
  */
 export interface ITelemetryPerformanceEventExt extends ITelemetryGenericEventExt {
-	duration?: number; // Duration of event (optional)
+	/**
+	 * Duration of event (optional)
+	 */
+	duration?: number;
 }
 
 /**
@@ -108,10 +127,10 @@ export interface ITelemetryPerformanceEventExt extends ITelemetryGenericEventExt
  */
 export interface ITelemetryLoggerExt extends ITelemetryBaseLogger {
 	/**
-	 * Send information telemetry event
-	 * @param event - Event to send
-	 * @param error - optional error object to log
-	 * @param logLevel - optional level of the log.
+	 * Send an information telemetry event.
+	 * @param event - Event to send.
+	 * @param error - Optional error object to log.
+	 * @param logLevel - Optional level of the log. Default: {@link @fluidframework/core-interfaces#LogLevel.default}.
 	 */
 	sendTelemetryEvent(
 		event: ITelemetryGenericEventExt,
@@ -120,17 +139,17 @@ export interface ITelemetryLoggerExt extends ITelemetryBaseLogger {
 	): void;
 
 	/**
-	 * Send error telemetry event
-	 * @param event - Event to send
-	 * @param error - optional error object to log
+	 * Send an error telemetry event.
+	 * @param event - Event to send.
+	 * @param error - Optional error object to log.
 	 */
 	sendErrorEvent(event: ITelemetryErrorEventExt, error?: unknown): void;
 
 	/**
-	 * Send performance telemetry event
+	 * Send a performance telemetry event.
 	 * @param event - Event to send
-	 * @param error - optional error object to log
-	 * @param logLevel - optional level of the log.
+	 * @param error - Optional error object to log.
+	 * @param logLevel - Optional level of the log. Default: {@link @fluidframework/core-interfaces#LogLevel.default}.
 	 */
 	sendPerformanceEvent(
 		event: ITelemetryPerformanceEventExt,

package/src/thresholdCounter.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLoggerExt } from "./telemetryTypes.js";
+import type { ITelemetryLoggerExt } from "./telemetryTypes.js";
 
 /**
  * Utility counter which will send event only if the provided value is above a configured threshold.