@fluidframework/telemetry-utils 2.0.0-dev-rc.5.0.0.271717 → 2.0.0-dev-rc.5.0.0.272889

package/src/config.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import {
+import type {
 	ConfigTypes,
 	IConfigProviderBase,
 	ITelemetryBaseLogger,
@@ -11,7 +11,7 @@ import {
 import { Lazy } from "@fluidframework/core-utils/internal";
 
 import { createChildLogger, tagCodeArtifacts } from "./logger.js";
-import { ITelemetryLoggerExt } from "./telemetryTypes.js";
+import type { ITelemetryLoggerExt } from "./telemetryTypes.js";
 
 /**
  * Explicitly typed interface for reading configurations.
@@ -193,7 +193,7 @@ export class CachedConfigProvider implements IConfigProvider {
 	private readonly configCache = new Map<string, StronglyTypedValue>();
 	private readonly orderedBaseProviders: (IConfigProviderBase | undefined)[];
 
-	constructor(
+	public constructor(
 		private readonly logger?: ITelemetryBaseLogger,
 		...orderedBaseProviders: (IConfigProviderBase | undefined)[]
 	) {
@@ -216,26 +216,26 @@ export class CachedConfigProvider implements IConfigProvider {
 			}
 		}
 	}
-	getBoolean(name: string): boolean | undefined {
+	public getBoolean(name: string): boolean | undefined {
 		return this.getCacheEntry(name)?.boolean;
 	}
-	getNumber(name: string): number | undefined {
+	public getNumber(name: string): number | undefined {
 		return this.getCacheEntry(name)?.number;
 	}
-	getString(name: string): string | undefined {
+	public getString(name: string): string | undefined {
 		return this.getCacheEntry(name)?.string;
 	}
-	getBooleanArray(name: string): boolean[] | undefined {
+	public getBooleanArray(name: string): boolean[] | undefined {
 		return this.getCacheEntry(name)?.["boolean[]"];
 	}
-	getNumberArray(name: string): number[] | undefined {
+	public getNumberArray(name: string): number[] | undefined {
 		return this.getCacheEntry(name)?.["number[]"];
 	}
-	getStringArray(name: string): string[] | undefined {
+	public getStringArray(name: string): string[] | undefined {
 		return this.getCacheEntry(name)?.["string[]"];
 	}
 
-	getRawConfig(name: string): ConfigTypes {
+	public getRawConfig(name: string): ConfigTypes {
 		return this.getCacheEntry(name)?.raw;
 	}
 
@@ -279,9 +279,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 = ITelemetryLoggerExt,
+>(obj: L): obj is L & MonitoringContext<L> {
 	const maybeConfig = obj as Partial<MonitoringContext<L>> | undefined;
 	return isConfigProviderBase(maybeConfig?.config) && maybeConfig?.logger !== undefined;
 }
@@ -291,9 +291,9 @@ export function loggerIsMonitoringContext<L extends ITelemetryBaseLogger = ITele
  *
  * @internal
  */
-export function loggerToMonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt>(
-	logger: L,
-): MonitoringContext<L> {
+export function loggerToMonitoringContext<
+	L extends ITelemetryBaseLogger = ITelemetryLoggerExt,
+>(logger: L): MonitoringContext<L> {
 	if (loggerIsMonitoringContext<L>(logger)) {
 		return logger;
 	}

package/src/error.ts

@@ -3,13 +3,13 @@
  * Licensed under the MIT License.
  */
 
-import { IErrorBase, ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
+import type { IErrorBase, ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
 import {
 	FluidErrorTypes,
-	IGenericError,
-	IUsageError,
+	type IGenericError,
+	type IUsageError,
 } from "@fluidframework/core-interfaces/internal";
-import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
+import type { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 
 import {
 	LoggingError,
@@ -18,8 +18,8 @@ import {
 	normalizeError,
 	wrapError,
 } from "./errorLogging.js";
-import { IFluidErrorBase } from "./fluidErrorBase.js";
-import { ITelemetryPropertiesExt } from "./telemetryTypes.js";
+import type { IFluidErrorBase } from "./fluidErrorBase.js";
+import type { ITelemetryPropertiesExt } from "./telemetryTypes.js";
 
 /**
  * Throws a UsageError with the given message if the condition is not met.
@@ -46,7 +46,7 @@ export function validatePrecondition(
  * @internal
  */
 export class GenericError extends LoggingError implements IGenericError, IFluidErrorBase {
-	readonly errorType = FluidErrorTypes.genericError;
+	public readonly errorType = FluidErrorTypes.genericError;
 
 	/**
 	 * Create a new GenericError
@@ -54,7 +54,7 @@ export class GenericError extends LoggingError implements IGenericError, IFluidE
 	 * @param error - inner error object
 	 * @param props - Telemetry props to include when the error is logged
 	 */
-	constructor(
+	public constructor(
 		message: string,
 		// TODO: Use `unknown` instead (API breaking change because error is not just an input parameter, but a public member of the class)
 		// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
@@ -72,9 +72,9 @@ export class GenericError extends LoggingError implements IGenericError, IFluidE
  * @internal
  */
 export class UsageError extends LoggingError implements IUsageError, IFluidErrorBase {
-	readonly errorType = FluidErrorTypes.usageError;
+	public readonly errorType = FluidErrorTypes.usageError;
 
-	constructor(message: string, props?: ITelemetryBaseProperties) {
+	public constructor(message: string, props?: ITelemetryBaseProperties) {
 		super(message, { ...props, usageError: true });
 	}
 }
@@ -86,10 +86,10 @@ export class UsageError extends LoggingError implements IUsageError, IFluidError
  * @internal
  */
 export class DataCorruptionError extends LoggingError implements IErrorBase, IFluidErrorBase {
-	readonly errorType = FluidErrorTypes.dataCorruptionError;
-	readonly canRetry = false;
+	public readonly errorType = FluidErrorTypes.dataCorruptionError;
+	public readonly canRetry = false;
 
-	constructor(message: string, props: ITelemetryBaseProperties) {
+	public constructor(message: string, props: ITelemetryBaseProperties) {
 		super(message, { ...props, dataProcessingError: 1 });
 	}
 }

package/src/errorLogging.ts

@@ -7,7 +7,7 @@ import type { ITelemetryBaseProperties, Tagged } from "@fluidframework/core-inte
 import type { ILoggingError } from "@fluidframework/core-interfaces/internal";
 import { v4 as uuid } from "uuid";
 
-import { IFluidErrorBase, hasErrorInstanceId, isFluidError } from "./fluidErrorBase.js";
+import { type IFluidErrorBase, hasErrorInstanceId, isFluidError } from "./fluidErrorBase.js";
 import { convertToBasePropertyType } from "./logger.js";
 import type {
 	ITelemetryLoggerExt,
@@ -157,7 +157,12 @@ export function normalizeError(
 
 	const errorTelemetryProps = LoggingError.typeCheck(error)
 		? error.getTelemetryProperties()
-		: { untrustedOrigin: 1 }; // This will let us filter errors that did not originate from our own codebase
+		: {
+				untrustedOrigin: 1, // This will let us filter errors that did not originate from our own codebase
+				// FUTURE: Once 2.0 becomes LTS, switch to this more explicit property name
+				// Consider using a string to distinguish cases like "dependency" v. "callback"
+				// errorRunningExternalCode: 1,
+			};
 
 	fluidError.addTelemetryProperties({
 		...errorTelemetryProps,
@@ -221,7 +226,10 @@ export function wrapError<T extends LoggingError>(
 	innerError: unknown,
 	newErrorFn: (message: string) => T,
 ): T {
-	const { message, stack } = extractLogSafeErrorProperties(innerError, false /* sanitizeStack */);
+	const { message, stack } = extractLogSafeErrorProperties(
+		innerError,
+		false /* sanitizeStack */,
+	);
 
 	const newError = newErrorFn(message);
 
@@ -231,7 +239,12 @@ export function wrapError<T extends LoggingError>(
 
 	// Mark external errors with untrustedOrigin flag
 	if (isExternalError(innerError)) {
-		newError.addTelemetryProperties({ untrustedOrigin: 1 });
+		newError.addTelemetryProperties({
+			untrustedOrigin: 1,
+			// FUTURE: Once 2.0 becomes LTS, switch to this more explicit property name
+			// Consider using a string to distinguish cases like "dependency" v. "callback"
+			// errorRunningExternalCode: 1,
+		});
 	}
 
 	// Reuse errorInstanceId
@@ -243,7 +256,7 @@ export function wrapError<T extends LoggingError>(
 	}
 
 	// Lastly, copy over all other telemetry properties. Note these will not overwrite existing properties
-	// This will include the untrustedOrigin property if the inner error itself was created from an external error
+	// This will include the untrustedOrigin/errorRunningExternalCode info if the inner error itself was created from an external error
 	if (isILoggingError(innerError)) {
 		newError.addTelemetryProperties(innerError.getTelemetryProperties());
 	}
@@ -308,11 +321,14 @@ export function overwriteStack(error: IFluidErrorBase | LoggingError, stack: str
  */
 export function isExternalError(error: unknown): boolean {
 	// LoggingErrors are an internal FF error type. However, an external error can be converted
-	// into a LoggingError if it is normalized. In this case we must use the untrustedOrigin flag to
-	// determine whether the original error was infact external.
+	// into a LoggingError if it is normalized. In this case we must use the untrustedOrigin/errorRunningExternalCode flag to
+	// determine whether the original error was in fact external.
 	if (LoggingError.typeCheck(error)) {
 		if ((error as NormalizedLoggingError).errorType === NORMALIZED_ERROR_TYPE) {
-			return error.getTelemetryProperties().untrustedOrigin === 1;
+			const props = error.getTelemetryProperties();
+			// NOTE: errorRunningExternalCode is not currently used - once this "read" code reaches LTS,
+			// we can switch to writing this more explicit property
+			return props.untrustedOrigin === 1 || !!props.errorRunningExternalCode;
 		}
 		return false;
 	}
@@ -331,6 +347,8 @@ export function isTaggedTelemetryPropertyValue(
 	return typeof (x as Partial<Tagged<unknown>>)?.tag === "string";
 }
 
+// TODO: Use `unknown` instead (API breaking change)
+/* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * Borrowed from
  * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cyclic_object_value#examples}
@@ -340,8 +358,6 @@ export function isTaggedTelemetryPropertyValue(
  *
  * @internal
  */
-// TODO: Use `unknown` instead (API breaking change)
-/* eslint-disable @typescript-eslint/no-explicit-any */
 export const getCircularReplacer = (): ((key: string, value: unknown) => any) => {
 	const seen = new WeakSet();
 	return (key: string, value: unknown): any => {
@@ -370,10 +386,10 @@ export class LoggingError
 	implements ILoggingError, Omit<IFluidErrorBase, "errorType">
 {
 	private _errorInstanceId = uuid();
-	get errorInstanceId(): string {
+	public get errorInstanceId(): string {
 		return this._errorInstanceId;
 	}
-	overwriteErrorInstanceId(id: string): void {
+	public overwriteErrorInstanceId(id: string): void {
 		this._errorInstanceId = id;
 	}
 
@@ -383,7 +399,7 @@ export class LoggingError
 	 * @param props - telemetry props to include on the error for when it's logged
 	 * @param omitPropsFromLogging - properties by name to omit from telemetry props
 	 */
-	constructor(
+	public constructor(
 		message: string,
 		props?: ITelemetryBaseProperties,
 		private readonly omitPropsFromLogging: Set<string> = new Set(),
@@ -464,9 +480,9 @@ export const NORMALIZED_ERROR_TYPE = "genericError";
 class NormalizedLoggingError extends LoggingError {
 	// errorType "genericError" is used as a default value throughout the code.
 	// Note that this matches ContainerErrorTypes/DriverErrorTypes' genericError
-	errorType = NORMALIZED_ERROR_TYPE;
+	public readonly errorType = NORMALIZED_ERROR_TYPE;
 
-	constructor(errorProps: Pick<IFluidErrorBase, "message" | "stack">) {
+	public constructor(errorProps: Pick<IFluidErrorBase, "message" | "stack">) {
 		super(errorProps.message);
 
 		if (errorProps.stack !== undefined) {

package/src/eventEmitterWithErrorHandling.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { EventEmitterEventType, TypedEventEmitter } from "@fluid-internal/client-utils";
-import { IEvent } from "@fluidframework/core-interfaces";
+import { type EventEmitterEventType, TypedEventEmitter } from "@fluid-internal/client-utils";
+import type { IEvent } from "@fluidframework/core-interfaces";
 
 /**
  * Event Emitter helper class
@@ -20,7 +20,7 @@ import { IEvent } from "@fluidframework/core-interfaces";
 export class EventEmitterWithErrorHandling<
 	TEvent extends IEvent = IEvent,
 > extends TypedEventEmitter<TEvent> {
-	constructor(
+	public constructor(
 		// TODO: use `unknown` instead (breaking API change)
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		private readonly errorHandler: (eventName: EventEmitterEventType, error: any) => void,

package/src/index.ts

@@ -5,10 +5,10 @@
 
 export {
 	createChildMonitoringContext,
-	MonitoringContext,
+	type MonitoringContext,
 	sessionStorageConfigProvider,
 	mixinMonitoringContext,
-	IConfigProvider,
+	type IConfigProvider,
 	loggerToMonitoringContext,
 	wrapConfigProviderWithDefaults,
 } from "./config.js";
@@ -25,7 +25,7 @@ export {
 	generateErrorWithStack,
 	generateStack,
 	getCircularReplacer,
-	IFluidErrorAnnotations,
+	type IFluidErrorAnnotations,
 	isExternalError,
 	isILoggingError,
 	isTaggedTelemetryPropertyValue,
@@ -43,29 +43,34 @@ export {
 	raiseConnectedEvent,
 	safeRaiseEvent,
 } from "./events.js";
-export { hasErrorInstanceId, IFluidErrorBase, isFluidError } from "./fluidErrorBase.js";
+export { hasErrorInstanceId, type IFluidErrorBase, isFluidError } from "./fluidErrorBase.js";
 export {
 	eventNamespaceSeparator,
 	createChildLogger,
 	createMultiSinkLogger,
 	formatTick,
-	IPerformanceEventMarkers,
-	ITelemetryLoggerPropertyBag,
-	ITelemetryLoggerPropertyBags,
-	MultiSinkLoggerProperties,
+	type IPerformanceEventMarkers,
+	type ITelemetryLoggerPropertyBag,
+	type ITelemetryLoggerPropertyBags,
+	type MultiSinkLoggerProperties,
 	numberFromString,
 	PerformanceEvent,
 	TaggedLoggerAdapter,
 	tagData,
 	tagCodeArtifacts,
 	TelemetryDataTag,
-	TelemetryEventPropertyTypes,
+	type TelemetryEventPropertyTypes,
 } from "./logger.js";
-export { MockLogger } from "./mockLogger.js";
+export { createMockLoggerExt, type IMockLoggerExt, MockLogger } from "./mockLogger.js";
 export { ThresholdCounter } from "./thresholdCounter.js";
 export { SampledTelemetryHelper } from "./sampledTelemetryHelper.js";
-export { createSampledLogger, IEventSampler, ISampledTelemetryLogger } from "./utils.js";
 export {
+	createSampledLogger,
+	type IEventSampler,
+	type ISampledTelemetryLogger,
+	measure,
+} from "./utils.js";
+export type {
 	TelemetryEventPropertyTypeExt,
 	ITelemetryEventExt,
 	ITelemetryGenericEventExt,
@@ -76,4 +81,4 @@ export {
 	ITelemetryPropertiesExt,
 	TelemetryEventCategory,
 } from "./telemetryTypes.js";
-export { type IMeasuredCodeResult, TelemetryEventBatcher } from "./telemetryEventBatcher.js";
+export { TelemetryEventBatcher } from "./telemetryEventBatcher.js";

package/src/logger.ts

@@ -5,11 +5,11 @@
 
 import { performance } from "@fluid-internal/client-utils";
 import {
-	ITelemetryBaseEvent,
-	ITelemetryBaseLogger,
+	type ITelemetryBaseEvent,
+	type ITelemetryBaseLogger,
 	LogLevel,
-	Tagged,
-	TelemetryBaseEventPropertyType,
+	type Tagged,
+	type TelemetryBaseEventPropertyType,
 } from "@fluidframework/core-interfaces";
 
 import {
@@ -23,8 +23,8 @@ import {
 	isILoggingError,
 	isTaggedTelemetryPropertyValue,
 } from "./errorLogging.js";
-import {
-	type ITelemetryErrorEventExt,
+import type {
+	ITelemetryErrorEventExt,
 	ITelemetryEventExt,
 	ITelemetryGenericEventExt,
 	ITelemetryLoggerExt,
@@ -60,9 +60,10 @@ export type TelemetryEventPropertyTypes = ITelemetryPropertiesExt[string];
 /**
  * @alpha
  */
-export interface ITelemetryLoggerPropertyBag {
-	[index: string]: TelemetryEventPropertyTypes | (() => TelemetryEventPropertyTypes);
-}
+export type ITelemetryLoggerPropertyBag = Record<
+	string,
+	TelemetryEventPropertyTypes | (() => TelemetryEventPropertyTypes)
+>;
 
 /**
  * @alpha
@@ -273,10 +274,9 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 		return this.extendProperties(newEvent, includeErrorProps);
 	}
 
-	private extendProperties<T extends ITelemetryLoggerPropertyBag = ITelemetryLoggerPropertyBag>(
-		toExtend: T,
-		includeErrorProps: boolean,
-	): T {
+	private extendProperties<
+		T extends ITelemetryLoggerPropertyBag = ITelemetryLoggerPropertyBag,
+	>(toExtend: T, includeErrorProps: boolean): T {
 		const eventLike: ITelemetryLoggerPropertyBag = toExtend;
 		if (this.properties) {
 			const properties: (undefined | ITelemetryLoggerPropertyBag)[] = [];
@@ -421,8 +421,8 @@ export class ChildLogger extends TelemetryLogger {
 				baseLogger.namespace === undefined
 					? namespace
 					: namespace === undefined
-					? baseLogger.namespace
-					: `${baseLogger.namespace}${TelemetryLogger.eventNamespaceSeparator}${namespace}`;
+						? baseLogger.namespace
+						: `${baseLogger.namespace}${TelemetryLogger.eventNamespaceSeparator}${namespace}`;
 
 			const child = new ChildLogger(
 				baseLogger.baseLogger,
@@ -533,7 +533,7 @@ export class MultiSinkLogger extends TelemetryLogger {
 	 * @param loggers - The list of loggers to use as sinks
 	 * @param tryInheritProperties - Will attempted to copy those loggers properties to this loggers if they are of a known type e.g. one from this package
 	 */
-	constructor(
+	public constructor(
 		namespace?: string,
 		properties?: ITelemetryLoggerPropertyBags,
 		loggers: ITelemetryBaseLogger[] = [],
@@ -855,7 +855,7 @@ export function convertToBasePropertyType(
 		? {
 				value: convertToBasePropertyTypeUntagged(x.value),
 				tag: x.tag,
-		  }
+			}
 		: convertToBasePropertyTypeUntagged(x);
 }
 
@@ -920,11 +920,11 @@ export const tagData = <
 				? () => {
 						value: ReturnType<V[P]>;
 						tag: T;
-				  }
+					}
 				: {
 						value: Exclude<V[P], undefined>;
 						tag: T;
-				  })
+					})
 		| (V[P] extends undefined ? undefined : never);
 } =>
 	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
@@ -982,10 +982,10 @@ export const tagCodeArtifacts = <
 				? () => {
 						value: ReturnType<T[P]>;
 						tag: TelemetryDataTag.CodeArtifact;
-				  }
+					}
 				: {
 						value: Exclude<T[P], undefined>;
 						tag: TelemetryDataTag.CodeArtifact;
-				  })
+					})
 		| (T[P] extends undefined ? undefined : never);
 } => tagData<TelemetryDataTag.CodeArtifact, T>(TelemetryDataTag.CodeArtifact, values);

package/src/mockLogger.ts

@@ -4,36 +4,55 @@
  */
 
 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.
  *
  * @alpha
  */
 export class MockLogger implements ITelemetryBaseLogger {
-	events: ITelemetryBaseEvent[] = [];
+	// TODO: don't expose mutability to external consumers
+	public events: ITelemetryBaseEvent[] = [];
+
+	/**
+	 * {@inheritDoc @fluidframework/core-interfaces#ITelemetryBaseLogger.minLogLevel}
+	 */
+	public readonly minLogLevel: LogLevel;
 
-	constructor(public readonly minLogLevel?: LogLevel) {}
+	public constructor(minLogLevel?: LogLevel) {
+		this.minLogLevel = minLogLevel ?? LogLevel.default;
+	}
 
-	clear(): void {
+	public clear(): void {
 		this.events = [];
 	}
 
-	toTelemetryLogger(): ITelemetryLoggerExt {
+	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);
+		}
 	}
 
 	/**
@@ -44,7 +63,7 @@ export class MockLogger implements ITelemetryBaseLogger {
 	 * 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.
 	 */
-	matchEvents(
+	public matchEvents(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		inlineDetailsProp: boolean = false,
 	): boolean {
@@ -60,7 +79,7 @@ export class MockLogger implements ITelemetryBaseLogger {
 	/**
 	 * Asserts that matchEvents is true, and prints the actual/expected output if not.
 	 */
-	assertMatch(
+	public assertMatch(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
@@ -85,7 +104,7 @@ ${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,
 	): boolean {
@@ -99,7 +118,7 @@ ${JSON.stringify(actualEvents)}`);
 	/**
 	 * Asserts that matchAnyEvent is true, and prints the actual/expected output if not.
 	 */
-	assertMatchAny(
+	public assertMatchAny(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
@@ -123,7 +142,7 @@ ${JSON.stringify(actualEvents)}`);
 	 * 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.
 	 */
-	matchEventStrict(
+	public matchEventStrict(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		inlineDetailsProp: boolean = false,
 	): boolean {
@@ -136,7 +155,7 @@ ${JSON.stringify(actualEvents)}`);
 	/**
 	 * Asserts that matchEvents is true, and prints the actual/expected output if not
 	 */
-	assertMatchStrict(
+	public assertMatchStrict(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
@@ -155,7 +174,7 @@ ${JSON.stringify(actualEvents)}`);
 	/**
 	 * Asserts that matchAnyEvent is false for the given events, and prints the actual/expected output if not
 	 */
-	assertMatchNone(
+	public assertMatchNone(
 		disallowedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
@@ -187,7 +206,7 @@ ${JSON.stringify(actualEvents)}`);
 		}
 
 		// Remove the events so far; next call will just compare subsequent events from here
-		this.events = [];
+		this.clear();
 
 		// Return the count of matched events.
 		return iExpectedEvent;
@@ -208,7 +227,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 +238,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 +266,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;
+}