@fluidframework/telemetry-utils 2.93.0 → 2.101.0

package/src/config.ts

@@ -8,10 +8,11 @@ import type {
 	IConfigProviderBase,
 	ITelemetryBaseLogger,
 } from "@fluidframework/core-interfaces";
+import { LogLevel } from "@fluidframework/core-interfaces";
 import { Lazy } from "@fluidframework/core-utils/internal";
 
 import { createChildLogger, tagCodeArtifacts } from "./logger.js";
-import type { ITelemetryLoggerExt } from "./telemetryTypes.js";
+import type { ITelemetryLoggerExt, TelemetryLoggerExt } from "./telemetryTypes.js";
 
 /**
  * Explicitly typed interface for reading configurations.
@@ -246,14 +247,17 @@ export class CachedConfigProvider implements IConfigProvider {
 				const parsed = stronglyTypedParse(provider?.getRawConfig(name));
 				if (parsed !== undefined) {
 					this.configCache.set(name, parsed);
-					this.logger?.send({
-						category: "generic",
-						eventName: "ConfigRead",
-						...tagCodeArtifacts({
-							configName: name,
-							configValue: JSON.stringify(parsed),
-						}),
-					});
+					this.logger?.send(
+						{
+							category: "generic",
+							eventName: "ConfigRead",
+							...tagCodeArtifacts({
+								configName: name,
+								configValue: JSON.stringify(parsed),
+							}),
+						},
+						LogLevel.info,
+					);
 					return parsed;
 				}
 			}
@@ -269,9 +273,13 @@ export class CachedConfigProvider implements IConfigProvider {
  *
  * @internal
  */
-export interface MonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt> {
+export interface MonitoringContext<L extends ITelemetryBaseLogger = TelemetryLoggerExt> {
 	config: IConfigProvider;
-	logger: L;
+	// Since this is an internal context, assume that any external logger type
+	// (`ITelemetryLoggerExt`) is just the internal `TelemetryLoggerExt` type.
+	// `extractTelemetryLoggerExt` can be used to extract the internal type, but
+	// we'll just "cast" it here.
+	logger: L extends ITelemetryLoggerExt ? TelemetryLoggerExt : L;
 }
 
 /**
@@ -280,9 +288,9 @@ export interface MonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLo
  *
  * @internal
  */
-export function loggerIsMonitoringContext<
-	L extends ITelemetryBaseLogger = ITelemetryLoggerExt,
->(obj: L): obj is L & MonitoringContext<L> {
+export function loggerIsMonitoringContext<L extends ITelemetryBaseLogger = TelemetryLoggerExt>(
+	obj: L,
+): obj is L & MonitoringContext<L> {
 	const maybeConfig = obj as Partial<MonitoringContext<L>> | undefined;
 	return isConfigProviderBase(maybeConfig?.config) && maybeConfig?.logger !== undefined;
 }
@@ -292,9 +300,9 @@ export function loggerIsMonitoringContext<
  *
  * @internal
  */
-export function loggerToMonitoringContext<
-	L extends ITelemetryBaseLogger = ITelemetryLoggerExt,
->(logger: L): MonitoringContext<L> {
+export function loggerToMonitoringContext<L extends ITelemetryBaseLogger = TelemetryLoggerExt>(
+	logger: L,
+): MonitoringContext<L> {
 	if (loggerIsMonitoringContext<L>(logger)) {
 		return logger;
 	}
@@ -312,7 +320,7 @@ export function loggerToMonitoringContext<
  *
  * @internal
  */
-export function mixinMonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt>(
+export function mixinMonitoringContext<L extends ITelemetryBaseLogger = TelemetryLoggerExt>(
 	logger: L,
 	...configs: (IConfigProviderBase | undefined)[]
 ): MonitoringContext<L> {
@@ -329,7 +337,9 @@ export function mixinMonitoringContext<L extends ITelemetryBaseLogger = ITelemet
 	 */
 	const mc: L & Partial<MonitoringContext<L>> = logger;
 	mc.config = new CachedConfigProvider(logger, ...configs);
-	mc.logger = logger;
+	// Cast is similar to `extractTelemetryLoggerExt` but preserves other
+	// logger types rather than just returning `TelemetryLoggerExt`.
+	mc.logger = logger as L extends ITelemetryLoggerExt ? TelemetryLoggerExt : L;
 	return mc as MonitoringContext<L>;
 }
 

package/src/errorLogging.ts

@@ -10,7 +10,7 @@ import { v4 as uuid } from "uuid";
 import { type IFluidErrorBase, hasErrorInstanceId, isFluidError } from "./fluidErrorBase.js";
 import { convertToBasePropertyType } from "./logger.js";
 import type {
-	ITelemetryLoggerExt,
+	TelemetryLoggerExt,
 	ITelemetryPropertiesExt,
 	TelemetryEventPropertyTypeExt,
 } from "./telemetryTypes.js";
@@ -286,7 +286,7 @@ export function wrapError<T extends LoggingError>(
 export function wrapErrorAndLog<T extends LoggingError>(
 	innerError: unknown,
 	newErrorFn: (message: string) => T,
-	logger: ITelemetryLoggerExt,
+	logger: TelemetryLoggerExt,
 ): T {
 	const newError = wrapError(innerError, newErrorFn);
 

package/src/events.ts

@@ -5,7 +5,7 @@
 
 import type { EventEmitter } from "@fluid-internal/client-utils";
 
-import type { ITelemetryLoggerExt } from "./telemetryTypes.js";
+import type { TelemetryLoggerExt } from "./telemetryTypes.js";
 
 /**
  * Note: The contents of this file really don't belong in this package, as they are only intended for internal use.
@@ -28,7 +28,7 @@ export const disconnectedEventName = "disconnected";
  */
 export function safeRaiseEvent(
 	emitter: EventEmitter,
-	logger: ITelemetryLoggerExt,
+	logger: TelemetryLoggerExt,
 	event: string,
 	...args: unknown[]
 ): void {
@@ -50,7 +50,7 @@ export function safeRaiseEvent(
  * @internal
  */
 export function raiseConnectedEvent(
-	logger: ITelemetryLoggerExt,
+	logger: TelemetryLoggerExt,
 	emitter: EventEmitter,
 	connected: boolean,
 	clientId?: string,

package/src/{index.ts → internal.ts}

@@ -3,6 +3,10 @@
  * Licensed under the MIT License.
  */
 
+// The "internal" exports are a superset of the standard ones. So, we want to export everything from the standard barrel file.
+// eslint-disable-next-line no-restricted-syntax
+export * from "./main.js";
+
 export {
 	createChildMonitoringContext,
 	type MonitoringContext,
@@ -40,7 +44,6 @@ export {
 	wrapError,
 	wrapErrorAndLog,
 } from "./errorLogging.js";
-export { EventEmitterWithErrorHandling } from "./eventEmitterWithErrorHandling.js";
 export {
 	connectedEventName,
 	disconnectedEventName,
@@ -57,10 +60,9 @@ export {
 	eventNamespaceSeparator,
 	createChildLogger,
 	createMultiSinkLogger,
+	extractTelemetryLoggerExt,
 	formatTick,
 	type IPerformanceEventMarkers,
-	type ITelemetryLoggerPropertyBag,
-	type ITelemetryLoggerPropertyBags,
 	type MultiSinkLoggerProperties,
 	numberFromString,
 	PerformanceEvent,
@@ -68,7 +70,7 @@ export {
 	tagData,
 	tagCodeArtifacts,
 	TelemetryDataTag,
-	type TelemetryEventPropertyTypes,
+	toITelemetryLoggerExt,
 } from "./logger.js";
 export {
 	createMockLoggerExt,
@@ -89,14 +91,27 @@ export {
 	measure,
 } from "./utils.js";
 export type {
-	TelemetryEventPropertyTypeExt,
 	ITelemetryEventExt,
+	TelemetryLoggerExt,
+} from "./telemetryTypes.js";
+export type {
 	ITelemetryGenericEventExt,
 	ITelemetryErrorEventExt,
 	ITelemetryPerformanceEventExt,
-	ITelemetryLoggerExt,
-	ITelemetryPropertiesExt,
 	TelemetryEventCategory,
-} from "./telemetryTypes.js";
+} from "./telemetryTypesUndeprecated.js";
 export { TelemetryEventBatcher } from "./telemetryEventBatcher.js";
 export { allowIncompatibleLayersKey, validateLayerCompatibility } from "./layerCompatError.js";
+
+import type { TelemetryLoggerExt } from "./telemetryTypes.js";
+
+/**
+ * Renamed version of TelemetryLoggerExt for convenience of internal use.
+ * Where "`ITelemetryLoggerExt`" is exposed in customer API surface, true
+ * `ITelemetryLoggerExt` (that is an erased type) must be used. To access
+ * use `@fluidframework/telemetry-utils/legacy` import spec. All internal
+ * usages should be promoted to `TelemetryLoggerExt` naming.
+ *
+ * @internal
+ */
+export type ITelemetryLoggerExt = TelemetryLoggerExt;

package/src/logger.ts

@@ -24,15 +24,55 @@ import {
 	isTaggedTelemetryPropertyValue,
 } from "./errorLogging.js";
 import type {
-	ITelemetryErrorEventExt,
 	ITelemetryEventExt,
-	ITelemetryGenericEventExt,
 	ITelemetryLoggerExt,
-	ITelemetryPerformanceEventExt,
 	ITelemetryPropertiesExt,
-	TelemetryEventCategory,
+	TelemetryLoggerExt,
 	TelemetryEventPropertyTypeExt,
 } from "./telemetryTypes.js";
+import type {
+	ITelemetryErrorEventExt,
+	ITelemetryGenericEventExt,
+	ITelemetryPerformanceEventExt,
+	TelemetryEventCategory,
+} from "./telemetryTypesUndeprecated.js";
+
+/**
+ * Type erase a {@link TelemetryLoggerExt} to an {@link ITelemetryLoggerExt}.
+ * @internal
+ */
+export function toITelemetryLoggerExt(logger: TelemetryLoggerExt): ITelemetryLoggerExt {
+	return logger as unknown as ITelemetryLoggerExt;
+}
+
+/**
+ * Un-type-erase the {@link ITelemetryLoggerExt}.
+ * @remarks
+ * This is the extraction helper as documented by {@link @fluidframework/core-interfaces#BrandedType}.
+ *
+ * @typeParam options - options for the extraction, currently only supports making
+ * the output possibly undefined (when `PossiblyUndefined: true`), which is useful
+ * for cases where we want to allow passing `undefined` through.
+ *
+ * @privateRemarks `ITelemetryLoggerExt` is not currently a branded type, but will
+ * be when the breaking change is made. At that time, use of this helper will be
+ * required.
+ *
+ * @internal
+ */
+export function extractTelemetryLoggerExt<
+	options extends {
+		PossiblyUndefined?: true;
+	} = // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- empty object without PossiblyUndefined is the correct type
+	{},
+>(
+	input:
+		| ITelemetryLoggerExt
+		| TelemetryLoggerExt
+		| (options["PossiblyUndefined"] extends true ? undefined : never),
+): TelemetryLoggerExt | (options["PossiblyUndefined"] extends true ? undefined : never) {
+	return input as unknown as TelemetryLoggerExt;
+}
 
 /**
  * Broad classifications to be applied to individual properties as they're prepared to be logged to telemetry.
@@ -70,6 +110,9 @@ export type ITelemetryLoggerPropertyBag = Record<
 /**
  * @legacy
  * @beta
+ *
+ * @privateRemarks
+ * This is exposed to support {@link createChildLogger} properties parameter.
  */
 export interface ITelemetryLoggerPropertyBags {
 	all?: ITelemetryLoggerPropertyBag;
@@ -115,7 +158,7 @@ export const eventNamespaceSeparator = ":";
  * encoding in one place schemas for various types of Fluid telemetry events.
  * Creates sub-logger that appends properties to all events
  */
-export abstract class TelemetryLogger implements ITelemetryLoggerExt {
+export abstract class TelemetryLogger implements TelemetryLoggerExt {
 	/**
 	 * {@inheritDoc eventNamespaceSeparator}
 	 */
@@ -181,18 +224,18 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 	 *
 	 * @param event - the event to send
 	 * @param error - optional error object to log
-	 * @param logLevel - optional level of the log. It category of event is set as error,
-	 * then the logLevel will be upgraded to be an error.
+	 * @param logLevel - optional level of the log. If the event's category is `error`,
+	 * the logLevel will be upgraded to {@link @fluidframework/core-interfaces#LogLevelConst.essential | LogLevel.essential}.
 	 */
 	public sendTelemetryEvent(
 		event: ITelemetryGenericEventExt,
 		error?: unknown,
-		logLevel: typeof LogLevel.verbose | typeof LogLevel.default = LogLevel.default,
+		logLevel?: typeof LogLevel.verbose | typeof LogLevel.info,
 	): void {
 		this.sendTelemetryEventCore(
 			{ ...event, category: event.category ?? "generic" },
 			error,
-			event.category === "error" ? LogLevel.error : logLevel,
+			event.category === "error" ? LogLevel.essential : (logLevel ?? LogLevel.essential),
 		);
 	}
 
@@ -201,12 +244,12 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 	 *
 	 * @param event - the event to send
 	 * @param error - optional error object to log
-	 * @param logLevel - optional level of the log.
+	 * @param logLevel - level of the log.
 	 */
-	protected sendTelemetryEventCore(
+	private sendTelemetryEventCore(
 		event: ITelemetryGenericEventExt & { category: TelemetryEventCategory },
-		error?: unknown,
-		logLevel?: LogLevel,
+		error: unknown,
+		logLevel: LogLevel,
 	): void {
 		const newEvent = convertToBaseEvent(event);
 		if (error !== undefined) {
@@ -237,7 +280,7 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 				category: "error",
 			},
 			error,
-			LogLevel.error,
+			LogLevel.essential,
 		);
 	}
 
@@ -246,13 +289,13 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 	 *
 	 * @param event - Event to send
 	 * @param error - optional error object to log
-	 * @param logLevel - optional level of the log. It category of event is set as error,
-	 * then the logLevel will be upgraded to be an error.
+	 * @param logLevel - optional level of the log. If the event's category is `error`,
+	 * the logLevel will be upgraded to {@link @fluidframework/core-interfaces#LogLevelConst.essential | LogLevel.essential}.
 	 */
 	public sendPerformanceEvent(
 		event: ITelemetryPerformanceEventExt,
 		error?: unknown,
-		logLevel: typeof LogLevel.verbose | typeof LogLevel.default = LogLevel.default,
+		logLevel?: typeof LogLevel.verbose | typeof LogLevel.info,
 	): void {
 		const perfEvent = {
 			...event,
@@ -262,7 +305,7 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 		this.sendTelemetryEventCore(
 			perfEvent,
 			error,
-			perfEvent.category === "error" ? LogLevel.error : logLevel,
+			perfEvent.category === "error" ? LogLevel.essential : (logLevel ?? LogLevel.essential),
 		);
 	}
 
@@ -361,6 +404,12 @@ export class TaggedLoggerAdapter implements ITelemetryBaseLogger {
 	}
 }
 
+function toEitherTelemetryLoggerExt(
+	logger: TelemetryLoggerExt,
+): TelemetryLoggerExt & ITelemetryLoggerExt {
+	return logger as TelemetryLoggerExt & ITelemetryLoggerExt;
+}
+
 /**
  * Create a child logger based on the provided props object.
  *
@@ -369,15 +418,25 @@ export class TaggedLoggerAdapter implements ITelemetryBaseLogger {
  *
  * @param props - logger is the base logger the child will log to after it's processing, namespace will be prefixed to all event names, properties are default properties that will be applied events.
  *
- * @legacy
- * @beta
+ * @internal
+ *
+ * @privateRemarks
+ * Return type is both TelemetryLoggerExt and ITelemetryLoggerExt to allow for
+ * easier internal usage without needing to type erase or un-type-erase the
+ * logger.
+ *
+ * If always creating a child logger for direct external exposure, consider
+ * using {@link createChildLogger} from /legacy API instead, which returns
+ * exactly an {@link ITelemetryLoggerExt}.
  */
 export function createChildLogger(props?: {
 	logger?: ITelemetryBaseLogger;
 	namespace?: string;
 	properties?: ITelemetryLoggerPropertyBags;
-}): ITelemetryLoggerExt {
-	return ChildLogger.create(props?.logger, props?.namespace, props?.properties);
+}): TelemetryLoggerExt & ITelemetryLoggerExt {
+	return toEitherTelemetryLoggerExt(
+		ChildLogger.create(props?.logger, props?.namespace, props?.properties),
+	);
 }
 
 /**
@@ -459,8 +518,8 @@ export class ChildLogger extends TelemetryLogger {
 	}
 
 	private shouldFilterOutEvent(event: ITelemetryBaseEvent, logLevel?: LogLevel): boolean {
-		const eventLogLevel = logLevel ?? LogLevel.default;
-		const configLogLevel = this.baseLogger.minLogLevel ?? LogLevel.default;
+		const eventLogLevel = logLevel ?? LogLevel.essential;
+		const configLogLevel = this.baseLogger.minLogLevel ?? LogLevel.info;
 		// Filter out in case event log level is below what is wanted in config.
 		return eventLogLevel < configLogLevel;
 	}
@@ -474,7 +533,7 @@ export class ChildLogger extends TelemetryLogger {
 		if (this.shouldFilterOutEvent(event, logLevel)) {
 			return;
 		}
-		this.baseLogger.send(this.prepareEvent(event), logLevel);
+		this.baseLogger.send(this.prepareEvent(event), logLevel ?? LogLevel.essential);
 	}
 }
 
@@ -510,7 +569,7 @@ export interface MultiSinkLoggerProperties {
  *
  * @internal
  */
-export function createMultiSinkLogger(props: MultiSinkLoggerProperties): ITelemetryLoggerExt {
+export function createMultiSinkLogger(props: MultiSinkLoggerProperties): TelemetryLoggerExt {
 	return new MultiSinkLogger(
 		props.namespace,
 		props.properties,
@@ -559,7 +618,7 @@ export class MultiSinkLogger extends TelemetryLogger {
 
 		super(namespace, realProperties);
 		this.loggers = loggers;
-		this._minLogLevelOfAllLoggers = LogLevel.default;
+		this._minLogLevelOfAllLoggers = LogLevel.info;
 		this.calculateMinLogLevel();
 	}
 
@@ -571,7 +630,7 @@ export class MultiSinkLogger extends TelemetryLogger {
 		if (this.loggers.length > 0) {
 			const logLevels: LogLevel[] = [];
 			for (const logger of this.loggers) {
-				logLevels.push(logger.minLogLevel ?? LogLevel.default);
+				logLevels.push(logger.minLogLevel ?? LogLevel.info);
 			}
 			this._minLogLevelOfAllLoggers = Math.min(...logLevels) as LogLevel;
 		}
@@ -594,10 +653,10 @@ export class MultiSinkLogger extends TelemetryLogger {
 	 *
 	 * @param event - the event to send to all the registered logger
 	 */
-	public send(event: ITelemetryBaseEvent): void {
+	public send(event: ITelemetryBaseEvent, logLevel?: LogLevel): void {
 		const newEvent = this.prepareEvent(event);
 		for (const logger of this.loggers) {
-			logger.send(newEvent);
+			logger.send(newEvent, logLevel ?? LogLevel.essential);
 		}
 	}
 }
@@ -633,15 +692,24 @@ export class PerformanceEvent {
 	 * @param recordHeapSize - whether or not to also record memory performance
 	 * @param emitLogs - should this instance emit logs. If set to false, logs will not be emitted to the logger,
 	 * but measurements will still be performed and any specified markers will be generated.
+	 * @param logLevel - optional {@link LogLevel} for events emitted by this performance event.
+	 * If unspecified, {@link @fluidframework/core-interfaces#LogLevelConst.essential | LogLevel.essential} will be used.
 	 * @returns An instance of {@link PerformanceEvent}
 	 */
 	public static start(
-		logger: ITelemetryLoggerExt,
+		logger: TelemetryLoggerExt | ITelemetryLoggerExt,
 		event: ITelemetryGenericEventExt,
 		markers?: IPerformanceEventMarkers,
 		emitLogs: boolean = true,
+		logLevel?: typeof LogLevel.verbose | typeof LogLevel.info,
 	): PerformanceEvent {
-		return new PerformanceEvent(logger, event, markers, emitLogs);
+		return new PerformanceEvent(
+			extractTelemetryLoggerExt(logger),
+			event,
+			markers,
+			emitLogs,
+			logLevel,
+		);
 	}
 
 	/**
@@ -652,6 +720,8 @@ export class PerformanceEvent {
 	 * @param markers - See {@link IPerformanceEventMarkers}
 	 * @param sampleThreshold - events with the same name and category will be sent to the logger
 	 * only when we hit this many executions of the task. If unspecified, all events will be sent.
+	 * @param logLevel - optional {@link LogLevel} for events emitted by this performance event.
+	 * If unspecified, {@link @fluidframework/core-interfaces#LogLevelConst.essential | LogLevel.essential} will be used.
 	 * @returns The results of the executed task
 	 *
 	 * @remarks Note that if the "same" event (category + eventName) would be emitted by different
@@ -660,17 +730,19 @@ export class PerformanceEvent {
 	 * effectively "share" the sampling rate for the event.
 	 */
 	public static timedExec<T>(
-		logger: ITelemetryLoggerExt,
+		logger: TelemetryLoggerExt,
 		event: ITelemetryGenericEventExt,
 		callback: (event: PerformanceEvent) => T,
 		markers?: IPerformanceEventMarkers,
 		sampleThreshold: number = 1,
+		logLevel?: typeof LogLevel.verbose | typeof LogLevel.info,
 	): T {
 		const perfEvent = PerformanceEvent.start(
 			logger,
 			event,
 			markers,
 			PerformanceEvent.shouldReport(event, sampleThreshold),
+			logLevel,
 		);
 		try {
 			const ret = callback(perfEvent);
@@ -691,6 +763,8 @@ export class PerformanceEvent {
 	 * @param recordHeapSize - whether or not to also record memory performance
 	 * @param sampleThreshold - events with the same name and category will be sent to the logger
 	 * only when we hit this many executions of the task. If unspecified, all events will be sent.
+	 * @param logLevel - optional {@link LogLevel} for events emitted by this performance event.
+	 * If unspecified, {@link @fluidframework/core-interfaces#LogLevelConst.essential | LogLevel.essential} will be used.
 	 * @returns The results of the executed task
 	 *
 	 * @remarks Note that if the "same" event (category + eventName) would be emitted by different
@@ -699,17 +773,19 @@ export class PerformanceEvent {
 	 * effectively "share" the sampling rate for the event.
 	 */
 	public static async timedExecAsync<T>(
-		logger: ITelemetryLoggerExt,
+		logger: TelemetryLoggerExt | ITelemetryLoggerExt,
 		event: ITelemetryGenericEventExt,
 		callback: (event: PerformanceEvent) => Promise<T>,
 		markers?: IPerformanceEventMarkers,
 		sampleThreshold: number = 1,
+		logLevel?: typeof LogLevel.verbose | typeof LogLevel.info,
 	): Promise<T> {
 		const perfEvent = PerformanceEvent.start(
 			logger,
 			event,
 			markers,
 			PerformanceEvent.shouldReport(event, sampleThreshold),
+			logLevel,
 		);
 		try {
 			const ret = await callback(perfEvent);
@@ -729,11 +805,12 @@ export class PerformanceEvent {
 	private readonly startTime = performanceNow();
 	private startMark?: string;
 
-	protected constructor(
-		private readonly logger: ITelemetryLoggerExt,
+	private constructor(
+		private readonly logger: TelemetryLoggerExt,
 		event: ITelemetryGenericEventExt,
 		private readonly markers: IPerformanceEventMarkers = { end: true, cancel: "generic" },
 		private readonly emitLogs: boolean = true,
+		private readonly logLevel: typeof LogLevel.verbose | typeof LogLevel.info | undefined,
 	) {
 		this.event = { ...event };
 		if (this.markers.start) {
@@ -818,7 +895,7 @@ export class PerformanceEvent {
 			event.duration = this.duration;
 		}
 
-		this.logger.sendPerformanceEvent(event, error);
+		this.logger.sendPerformanceEvent(event, error, this.logLevel);
 	}
 
 	private static readonly eventHits = new Map<string, number>();

package/src/main.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+// This export set contains public APIs that don't have any special treatment
+// when exposed internally. APIs deprecated for external use but still needed
+// internally are re-exported from /internal with alternate tagging.
+
+export { EventEmitterWithErrorHandling } from "./eventEmitterWithErrorHandling.js";
+export type {
+	ITelemetryLoggerPropertyBag,
+	ITelemetryLoggerPropertyBags,
+	TelemetryEventPropertyTypes,
+} from "./logger.js";
+export type {
+	ITelemetryPropertiesExt,
+	TelemetryEventPropertyTypeExt,
+} from "./telemetryTypes.js";

package/src/mockLogger.ts

@@ -13,7 +13,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 import { createChildLogger } from "./logger.js";
 import type {
 	ITelemetryEventExt,
-	ITelemetryLoggerExt,
+	TelemetryLoggerExt,
 	ITelemetryPropertiesExt,
 } from "./telemetryTypes.js";
 
@@ -41,7 +41,7 @@ export class MockLogger implements ITelemetryBaseLogger {
 	public readonly minLogLevel: LogLevel;
 
 	public constructor(minLogLevel?: LogLevel) {
-		this.minLogLevel = minLogLevel ?? LogLevel.default;
+		this.minLogLevel = minLogLevel ?? LogLevel.info;
 	}
 
 	/**
@@ -51,7 +51,7 @@ export class MockLogger implements ITelemetryBaseLogger {
 		this._events = [];
 	}
 
-	public toTelemetryLogger(): ITelemetryLoggerExt {
+	public toTelemetryLogger(): ReturnType<typeof createChildLogger> {
 		return createChildLogger({ logger: this });
 	}
 
@@ -59,7 +59,7 @@ export class MockLogger implements ITelemetryBaseLogger {
 	 * {@inheritDoc @fluidframework/core-interfaces#ITelemetryBaseLogger.send}
 	 */
 	public send(event: ITelemetryBaseEvent, logLevel?: LogLevel): void {
-		if ((logLevel ?? LogLevel.default) >= this.minLogLevel) {
+		if ((logLevel ?? LogLevel.essential) >= this.minLogLevel) {
 			this._events.push(event);
 		}
 	}
@@ -357,13 +357,13 @@ function matchObjects(
 }
 
 /**
- * Mock {@link ITelemetryLoggerExt} implementation.
+ * Mock {@link TelemetryLoggerExt} implementation.
  *
  * @remarks Can be created via {@link createMockLoggerExt}.
  *
  * @internal
  */
-export interface IMockLoggerExt extends ITelemetryLoggerExt {
+export interface IMockLoggerExt extends TelemetryLoggerExt {
 	/**
 	 * Gets the events that have been logged so far.
 	 */