@fluidframework/telemetry-utils 2.0.0-internal.6.1.1 → 2.0.0-internal.6.2.0

package/src/fluidErrorBase.ts

@@ -6,62 +6,98 @@
 import { ITelemetryProperties } from "@fluidframework/core-interfaces";
 
 /**
+ * An error emitted by the Fluid Framework.
+ *
+ * @remarks
+ *
  * All normalized errors flowing through the Fluid Framework adhere to this readonly interface.
- * It features errorType and errorInstanceId on top of Error's members as readonly,
- * and a getter/setter for telemetry props to be included when the error is logged.
+ *
+ * It features the members of {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error | Error}
+ * made readonly, as well as  {@link IFluidErrorBase.errorType} and {@link IFluidErrorBase.errorInstanceId}.
+ * It also features getters and setters for telemetry props to be included when the error is logged.
  */
 export interface IFluidErrorBase extends Error {
-	/** Classification of what type of error this is, used programmatically by consumers to interpret the error */
+	/**
+	 * Classification of what type of error this is.
+	 *
+	 * @remarks Used programmatically by consumers to interpret the error.
+	 */
 	readonly errorType: string;
 
 	/**
 	 * Error's message property, made readonly.
-	 * Be specific, but also take care when including variable data to consider suitability for aggregation in telemetry
-	 * Also avoid including any data that jeopardizes the user's privacy.  Add a tagged telemetry property instead.
+	 *
+	 * @remarks
+	 *
+	 * Recommendations:
+	 *
+	 * Be specific, but also take care when including variable data to consider suitability for aggregation in telemetry.
+	 * Also avoid including any data that jeopardizes the user's privacy. Add a tagged telemetry property instead.
 	 */
 	readonly message: string;
 
-	/** Error's stack property, made readonly */
+	/**
+	 * See {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/stack}.
+	 */
 	readonly stack?: string;
 
-	/** Error's name property, made readonly */
+	/**
+	 * See {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name}.
+	 */
 	readonly name: string;
 
 	/**
 	 * A Guid identifying this error instance.
-	 * Useful in telemetry for deduping multiple logging events arising from the same error,
+	 *
+	 * @remarks
+	 *
+	 * Useful in telemetry for deduplicating multiple logging events arising from the same error,
 	 * or correlating an error with an inner error that caused it, in case of error wrapping.
 	 */
 	readonly errorInstanceId: string;
 
-	/** Get the telemetry properties stashed on this error for logging */
+	/**
+	 * Get the telemetry properties stashed on this error for logging.
+	 */
 	getTelemetryProperties(): ITelemetryProperties;
-	/** Add telemetry properties to this error which will be logged with the error */
+
+	/**
+	 * Add telemetry properties to this error which will be logged with the error
+	 */
 	addTelemetryProperties: (props: ITelemetryProperties) => void;
 }
 
-const hasTelemetryPropFunctions = (x: any): boolean =>
-	typeof x?.getTelemetryProperties === "function" &&
-	typeof x?.addTelemetryProperties === "function";
+const hasTelemetryPropFunctions = (x: unknown): boolean =>
+	typeof (x as Partial<IFluidErrorBase>)?.getTelemetryProperties === "function" &&
+	typeof (x as Partial<IFluidErrorBase>)?.addTelemetryProperties === "function";
 
-export const hasErrorInstanceId = (x: any): x is { errorInstanceId: string } =>
-	typeof x?.errorInstanceId === "string";
+/**
+ * Type guard for error data containing the {@link IFluidErrorBase.errorInstanceId} property.
+ */
+export const hasErrorInstanceId = (x: unknown): x is { errorInstanceId: string } =>
+	typeof (x as Partial<{ errorInstanceId: string }>)?.errorInstanceId === "string";
 
-/** type guard for IFluidErrorBase interface */
-export function isFluidError(e: any): e is IFluidErrorBase {
+/**
+ * Type guard for {@link IFluidErrorBase}.
+ */
+export function isFluidError(error: unknown): error is IFluidErrorBase {
 	return (
-		typeof e?.errorType === "string" &&
-		typeof e?.message === "string" &&
-		hasErrorInstanceId(e) &&
-		hasTelemetryPropFunctions(e)
+		typeof (error as Partial<IFluidErrorBase>)?.errorType === "string" &&
+		typeof (error as Partial<IFluidErrorBase>)?.message === "string" &&
+		hasErrorInstanceId(error) &&
+		hasTelemetryPropFunctions(error)
 	);
 }
 
-/** type guard for old standard of valid/known errors */
-export function isValidLegacyError(e: any): e is Omit<IFluidErrorBase, "errorInstanceId"> {
+/**
+ * Type guard for old standard of valid/known errors.
+ */
+export function isValidLegacyError(
+	error: unknown,
+): error is Omit<IFluidErrorBase, "errorInstanceId"> {
 	return (
-		typeof e?.errorType === "string" &&
-		typeof e?.message === "string" &&
-		hasTelemetryPropFunctions(e)
+		typeof (error as Partial<IFluidErrorBase>)?.errorType === "string" &&
+		typeof (error as Partial<IFluidErrorBase>)?.message === "string" &&
+		hasTelemetryPropFunctions(error)
 	);
 }

package/src/index.ts

@@ -12,6 +12,13 @@ export {
 	ConfigTypes,
 	loggerToMonitoringContext,
 } from "./config";
+export {
+	DataCorruptionError,
+	DataProcessingError,
+	extractSafePropertiesFromMessage,
+	GenericError,
+	UsageError,
+} from "./error";
 export {
 	extractLogSafeErrorProperties,
 	generateErrorWithStack,

package/src/logger.ts

@@ -13,6 +13,7 @@ import {
 	TelemetryEventPropertyType,
 	ITaggedTelemetryPropertyType,
 	TelemetryEventCategory,
+	LogLevel,
 } from "@fluidframework/core-interfaces";
 import { IsomorphicPerformance, performance } from "@fluidframework/common-utils";
 import { CachedConfigProvider, loggerIsMonitoringContext, mixinMonitoringContext } from "./config";
@@ -28,6 +29,7 @@ import {
 	ITelemetryGenericEventExt,
 	ITelemetryLoggerExt,
 	ITelemetryPerformanceEventExt,
+	ITelemetryPropertiesExt,
 	TelemetryEventPropertyTypeExt,
 } from "./telemetryTypes";
 
@@ -43,9 +45,13 @@ export interface PerformanceWithMemory extends IsomorphicPerformance {
  * Please do not modify existing entries for backwards compatibility.
  */
 export enum TelemetryDataTag {
-	/** Data containing terms or IDs from code packages that may have been dynamically loaded */
+	/**
+	 * Data containing terms or IDs from code packages that may have been dynamically loaded
+	 */
 	CodeArtifact = "CodeArtifact",
-	/** Personal data of a variety of classifications that pertains to the user */
+	/**
+	 * Personal data of a variety of classifications that pertains to the user
+	 */
 	UserData = "UserData",
 }
 
@@ -65,6 +71,7 @@ export interface ITelemetryLoggerPropertyBags {
  * Used to make telemetry data typed (and support math operations, like comparison),
  * in places where we do expect numbers (like contentsize/duration property in http header)
  */
+// eslint-disable-next-line @rushstack/no-new-null
 export function numberFromString(str: string | null | undefined): string | number | undefined {
 	if (str === undefined || str === null) {
 		return undefined;
@@ -83,12 +90,11 @@ export const eventNamespaceSeparator = ":" as const;
  * TelemetryLogger class contains various helper telemetry methods,
  * 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 {
 	public static readonly eventNamespaceSeparator = eventNamespaceSeparator;
 
-	public static sanitizePkgName(name: string) {
+	public static sanitizePkgName(name: string): string {
 		return name.replace("@", "").replace("/", "-");
 	}
 
@@ -99,7 +105,11 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 	 * @param error - Error to extract info from
 	 * @param fetchStack - Whether to fetch the current callstack if error.stack is undefined
 	 */
-	public static prepareErrorObject(event: ITelemetryBaseEvent, error: any, fetchStack: boolean) {
+	public static prepareErrorObject(
+		event: ITelemetryBaseEvent,
+		error: unknown,
+		fetchStack: boolean,
+	): void {
 		const { message, errorType, stack } = extractLogSafeErrorProperties(
 			error,
 			true /* sanitizeStack */,
@@ -137,16 +147,26 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 	 *
 	 * @param event - the event to send
 	 */
-	public abstract send(event: ITelemetryBaseEvent): void;
+	public abstract send(event: ITelemetryBaseEvent, logLevel?: LogLevel): void;
 
 	/**
 	 * Send a telemetry event with the logger
 	 *
 	 * @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.
 	 */
-	public sendTelemetryEvent(event: ITelemetryGenericEventExt, error?: any) {
-		this.sendTelemetryEventCore({ ...event, category: event.category ?? "generic" }, error);
+	public sendTelemetryEvent(
+		event: ITelemetryGenericEventExt,
+		error?: unknown,
+		logLevel: LogLevel.verbose | LogLevel.default = LogLevel.default,
+	): void {
+		this.sendTelemetryEventCore(
+			{ ...event, category: event.category ?? "generic" },
+			error,
+			event.category === "error" ? LogLevel.error : logLevel,
+		);
 	}
 
 	/**
@@ -154,11 +174,13 @@ 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.
 	 */
 	protected sendTelemetryEventCore(
 		event: ITelemetryGenericEventExt & { category: TelemetryEventCategory },
-		error?: any,
-	) {
+		error?: unknown,
+		logLevel?: LogLevel,
+	): void {
 		const newEvent = convertToBaseEvent(event);
 		if (error !== undefined) {
 			TelemetryLogger.prepareErrorObject(newEvent, error, false);
@@ -169,7 +191,7 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 			newEvent.duration = formatTick(newEvent.duration);
 		}
 
-		this.send(newEvent);
+		this.send(newEvent, logLevel);
 	}
 
 	/**
@@ -178,7 +200,7 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 	 * @param event - the event to send
 	 * @param error - optional error object to log
 	 */
-	public sendErrorEvent(event: ITelemetryErrorEvent, error?: any) {
+	public sendErrorEvent(event: ITelemetryErrorEvent, error?: unknown): void {
 		this.sendTelemetryEventCore(
 			{
 				// ensure the error field has some value,
@@ -188,6 +210,7 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 				category: "error",
 			},
 			error,
+			LogLevel.error,
 		);
 	}
 
@@ -196,14 +219,24 @@ 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.
 	 */
-	public sendPerformanceEvent(event: ITelemetryPerformanceEventExt, error?: any): void {
+	public sendPerformanceEvent(
+		event: ITelemetryPerformanceEventExt,
+		error?: unknown,
+		logLevel: LogLevel.verbose | LogLevel.default = LogLevel.default,
+	): void {
 		const perfEvent = {
 			...event,
 			category: event.category ?? "performance",
 		};
 
-		this.sendTelemetryEventCore(perfEvent, error);
+		this.sendTelemetryEventCore(
+			perfEvent,
+			error,
+			perfEvent.category === "error" ? LogLevel.error : logLevel,
+		);
 	}
 
 	protected prepareEvent(event: ITelemetryBaseEvent): ITelemetryBaseEvent {
@@ -220,7 +253,7 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 	private extendProperties<T extends ITelemetryLoggerPropertyBag = ITelemetryLoggerPropertyBag>(
 		toExtend: T,
 		includeErrorProps: boolean,
-	) {
+	): T {
 		const eventLike: ITelemetryLoggerPropertyBag = toExtend;
 		if (this.properties) {
 			const properties: (undefined | ITelemetryLoggerPropertyBag)[] = [];
@@ -257,7 +290,10 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 export class TaggedLoggerAdapter implements ITelemetryBaseLogger {
 	public constructor(private readonly logger: ITelemetryBaseLogger) {}
 
-	public send(eventWithTagsMaybe: ITelemetryBaseEvent) {
+	/**
+	 * {@inheritDoc @fluidframework/core-interfaces#ITelemetryBaseLogger.send}
+	 */
+	public send(eventWithTagsMaybe: ITelemetryBaseEvent): void {
 		const newEvent: ITelemetryBaseEvent = {
 			category: eventWithTagsMaybe.category,
 			eventName: eventWithTagsMaybe.eventName,
@@ -368,7 +404,11 @@ export class ChildLogger extends TelemetryLogger {
 			return child;
 		}
 
-		return new ChildLogger(baseLogger ? baseLogger : { send() {} }, namespace, properties);
+		return new ChildLogger(
+			baseLogger ? baseLogger : { send(): void {} },
+			namespace,
+			properties,
+		);
 	}
 
 	private constructor(
@@ -384,13 +424,23 @@ export class ChildLogger extends TelemetryLogger {
 		}
 	}
 
+	private shouldFilterOutEvent(event: ITelemetryPropertiesExt, logLevel?: LogLevel): boolean {
+		const eventLogLevel = logLevel ?? LogLevel.default;
+		const configLogLevel = this.baseLogger.minLogLevel ?? LogLevel.default;
+		// Filter out in case event log level is below what is wanted in config.
+		return eventLogLevel < configLogLevel;
+	}
+
 	/**
 	 * Send an event with the logger
 	 *
 	 * @param event - the event to send
 	 */
-	public send(event: ITelemetryBaseEvent): void {
-		this.baseLogger.send(this.prepareEvent(event));
+	public send(event: ITelemetryBaseEvent, logLevel?: LogLevel): void {
+		if (this.shouldFilterOutEvent(event, logLevel)) {
+			return;
+		}
+		this.baseLogger.send(this.prepareEvent(event), logLevel);
 	}
 }
 
@@ -438,8 +488,11 @@ export class MultiSinkLogger extends TelemetryLogger {
 			loggers
 				.filter((l): l is this => l instanceof TelemetryLogger)
 				.map((l) => l.properties ?? {})
+				// eslint-disable-next-line unicorn/no-array-for-each
 				.forEach((cv) => {
+					// eslint-disable-next-line unicorn/no-array-for-each
 					Object.keys(cv).forEach((k) => {
+						// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 						merge[k] = { ...cv[k], ...merge?.[k] };
 					});
 				});
@@ -453,7 +506,7 @@ export class MultiSinkLogger extends TelemetryLogger {
 	 * Add logger to send all events to
 	 * @param logger - Logger to add
 	 */
-	public addLogger(logger?: ITelemetryBaseLogger) {
+	public addLogger(logger?: ITelemetryBaseLogger): void {
 		if (logger !== undefined && logger !== null) {
 			this.loggers.push(logger);
 		}
@@ -466,9 +519,9 @@ export class MultiSinkLogger extends TelemetryLogger {
 	 */
 	public send(event: ITelemetryBaseEvent): void {
 		const newEvent = this.prepareEvent(event);
-		this.loggers.forEach((logger: ITelemetryBaseLogger) => {
+		for (const logger of this.loggers) {
 			logger.send(newEvent);
-		});
+		}
 	}
 }
 
@@ -493,7 +546,7 @@ export class PerformanceEvent {
 		event: ITelemetryGenericEvent,
 		markers?: IPerformanceEventMarkers,
 		recordHeapSize: boolean = false,
-	) {
+	): PerformanceEvent {
 		return new PerformanceEvent(logger, event, markers, recordHeapSize);
 	}
 
@@ -502,7 +555,7 @@ export class PerformanceEvent {
 		event: ITelemetryGenericEvent,
 		callback: (event: PerformanceEvent) => T,
 		markers?: IPerformanceEventMarkers,
-	) {
+	): T {
 		const perfEvent = PerformanceEvent.start(logger, event, markers);
 		try {
 			const ret = callback(perfEvent);
@@ -520,7 +573,7 @@ export class PerformanceEvent {
 		callback: (event: PerformanceEvent) => Promise<T>,
 		markers?: IPerformanceEventMarkers,
 		recordHeapSize?: boolean,
-	) {
+	): Promise<T> {
 		const perfEvent = PerformanceEvent.start(logger, event, markers, recordHeapSize);
 		try {
 			const ret = await callback(perfEvent);
@@ -532,7 +585,7 @@ export class PerformanceEvent {
 		}
 	}
 
-	public get duration() {
+	public get duration(): number {
 		return performance.now() - this.startTime;
 	}
 
@@ -552,6 +605,7 @@ export class PerformanceEvent {
 			this.reportEvent("start");
 		}
 
+		// eslint-disable-next-line unicorn/no-null
 		if (typeof window === "object" && window != null && window.performance?.mark) {
 			this.startMark = `${event.eventName}-start`;
 			window.performance.mark(this.startMark);
@@ -562,7 +616,7 @@ export class PerformanceEvent {
 		this.reportEvent(eventNameSuffix, props);
 	}
 
-	private autoEnd() {
+	private autoEnd(): void {
 		// Event might have been cancelled or ended in the callback
 		if (this.event && this.markers.end) {
 			this.reportEvent("end");
@@ -577,7 +631,7 @@ export class PerformanceEvent {
 		this.event = undefined;
 	}
 
-	private performanceEndMark() {
+	private performanceEndMark(): void {
 		if (this.startMark && this.event) {
 			const endMark = `${this.event.eventName}-end`;
 			window.performance.mark(endMark);
@@ -586,7 +640,7 @@ export class PerformanceEvent {
 		}
 	}
 
-	public cancel(props?: ITelemetryProperties, error?: any): void {
+	public cancel(props?: ITelemetryProperties, error?: unknown): void {
 		if (this.markers.cancel !== undefined) {
 			this.reportEvent("cancel", { category: this.markers.cancel, ...props }, error);
 		}
@@ -596,7 +650,11 @@ export class PerformanceEvent {
 	/**
 	 * Report the event, if it hasn't already been reported.
 	 */
-	public reportEvent(eventNameSuffix: string, props?: ITelemetryProperties, error?: any) {
+	public reportEvent(
+		eventNameSuffix: string,
+		props?: ITelemetryProperties,
+		error?: unknown,
+	): void {
 		// There are strange sequences involving multiple Promise chains
 		// where the event can be cancelled and then later a callback is invoked
 		// and the caller attempts to end directly, e.g. issue #3936. Just return.
@@ -637,9 +695,9 @@ export class PerformanceEvent {
  */
 export class TelemetryNullLogger implements ITelemetryLoggerExt {
 	public send(event: ITelemetryBaseEvent): void {}
-	public sendTelemetryEvent(event: ITelemetryGenericEvent, error?: any): void {}
-	public sendErrorEvent(event: ITelemetryErrorEvent, error?: any): void {}
-	public sendPerformanceEvent(event: ITelemetryPerformanceEvent, error?: any): void {}
+	public sendTelemetryEvent(event: ITelemetryGenericEvent, error?: unknown): void {}
+	public sendErrorEvent(event: ITelemetryErrorEvent, error?: unknown): void {}
+	public sendPerformanceEvent(event: ITelemetryPerformanceEvent, error?: unknown): void {}
 }
 
 /**
@@ -706,9 +764,17 @@ export const tagData = <
 >(
 	tag: T,
 	values: V,
-) =>
+): {
+	[P in keyof V]:
+		| {
+				value: Exclude<V[P], undefined>;
+				tag: T;
+		  }
+		| (V[P] extends undefined ? undefined : never);
+} =>
 	(Object.entries(values) as [keyof V, V[keyof V]][])
 		.filter((e): e is [keyof V, Exclude<V[keyof V], undefined>] => e[1] !== undefined)
+		// eslint-disable-next-line unicorn/no-array-reduce
 		.reduce<{
 			[P in keyof V]:
 				| (V[P] extends undefined ? undefined : never)
@@ -716,8 +782,16 @@ export const tagData = <
 		}>((pv, cv) => {
 			pv[cv[0]] = { tag, value: cv[1] };
 			return pv;
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
 		}, {} as any);
 
 export const tagCodeArtifacts = <T extends Record<string, TelemetryEventPropertyTypeExt>>(
 	values: T,
-) => tagData(TelemetryDataTag.CodeArtifact, values);
+): {
+	[P in keyof T]:
+		| {
+				value: Exclude<T[P], undefined>;
+				tag: TelemetryDataTag.CodeArtifact;
+		  }
+		| (T[P] extends undefined ? undefined : never);
+} => tagData(TelemetryDataTag.CodeArtifact, values);

package/src/mockLogger.ts

@@ -5,7 +5,7 @@
 
 import { ITelemetryBaseEvent, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/common-utils";
-import { ITelemetryPropertiesExt } from "./telemetryTypes";
+import { ITelemetryLoggerExt, ITelemetryPropertiesExt } from "./telemetryTypes";
 import { createChildLogger } from "./logger";
 
 /**
@@ -15,11 +15,11 @@ import { createChildLogger } from "./logger";
 export class MockLogger implements ITelemetryBaseLogger {
 	events: ITelemetryBaseEvent[] = [];
 
-	clear() {
+	clear(): void {
 		this.events = [];
 	}
 
-	toTelemetryLogger() {
+	toTelemetryLogger(): ITelemetryLoggerExt {
 		return createChildLogger({ logger: this });
 	}
 
@@ -48,12 +48,14 @@ export class MockLogger implements ITelemetryBaseLogger {
 		return unmatchedExpectedEventCount === 0;
 	}
 
-	/** Asserts that matchEvents is true, and prints the actual/expected output if not */
+	/**
+	 * Asserts that matchEvents is true, and prints the actual/expected output if not.
+	 */
 	assertMatch(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
-	) {
+	): void {
 		const actualEvents = this.events;
 		if (!this.matchEvents(expectedEvents, inlineDetailsProp)) {
 			throw new Error(`${message}
@@ -85,12 +87,14 @@ ${JSON.stringify(actualEvents)}`);
 		return matchedExpectedEventCount > 0;
 	}
 
-	/** Asserts that matchAnyEvent is true, and prints the actual/expected output if not */
+	/**
+	 * Asserts that matchAnyEvent is true, and prints the actual/expected output if not.
+	 */
 	assertMatchAny(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
-	) {
+	): void {
 		const actualEvents = this.events;
 		if (!this.matchAnyEvent(expectedEvents, inlineDetailsProp)) {
 			throw new Error(`${message}
@@ -120,12 +124,14 @@ ${JSON.stringify(actualEvents)}`);
 		);
 	}
 
-	/** Asserts that matchEvents is true, and prints the actual/expected output if not */
+	/**
+	 * Asserts that matchEvents is true, and prints the actual/expected output if not
+	 */
 	assertMatchStrict(
 		expectedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
-	) {
+	): void {
 		const actualEvents = this.events;
 		if (!this.matchEventStrict(expectedEvents, inlineDetailsProp)) {
 			throw new Error(`${message}
@@ -137,12 +143,14 @@ ${JSON.stringify(actualEvents)}`);
 		}
 	}
 
-	/** Asserts that matchAnyEvent is false for the given events, and prints the actual/expected output if not */
+	/**
+	 * Asserts that matchAnyEvent is false for the given events, and prints the actual/expected output if not
+	 */
 	assertMatchNone(
 		disallowedEvents: Omit<ITelemetryBaseEvent, "category">[],
 		message?: string,
 		inlineDetailsProp: boolean = false,
-	) {
+	): void {
 		const actualEvents = this.events;
 		if (this.matchAnyEvent(disallowedEvents, inlineDetailsProp)) {
 			throw new Error(`${message}
@@ -159,7 +167,7 @@ ${JSON.stringify(actualEvents)}`);
 		inlineDetailsProp: boolean,
 	): number {
 		let iExpectedEvent = 0;
-		this.events.forEach((event) => {
+		for (const event of this.events) {
 			if (
 				iExpectedEvent < expectedEvents.length &&
 				MockLogger.eventsMatch(event, expectedEvents[iExpectedEvent], inlineDetailsProp)
@@ -167,7 +175,7 @@ ${JSON.stringify(actualEvents)}`);
 				// We found the next expected event; increment
 				++iExpectedEvent;
 			}
-		});
+		}
 
 		// Remove the events so far; next call will just compare subsequent events from here
 		this.events = [];
@@ -191,16 +199,19 @@ ${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
 			const detailsExpanded = JSON.parse(details);
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
 			return matchObjects({ ...actualForMatching, ...detailsExpanded }, expected);
 		}
 		return matchObjects(actual, expected);
 	}
 }
 
-function matchObjects(actual: ITelemetryPropertiesExt, expected: ITelemetryPropertiesExt) {
+function matchObjects(actual: ITelemetryPropertiesExt, expected: ITelemetryPropertiesExt): boolean {
 	for (const [expectedKey, expectedValue] of Object.entries(expected)) {
 		const actualValue = actual[expectedKey];
 		if (