Add minLogLevel calculation logic to MultiSinkLogger (#17148)

## Description

Add minLogLevel calculation logic to MultiSinkLogger. Currently we wrap
the loggers we provide to loader etc in multisink and therefore we need
to add the logic here so that the events are properly filtered and the
childLogger can access the loglevel of the multisinklogger.

---------

Co-authored-by: Jatin Garg <[email protected]>

Author: jatgarg

api-report/core-interfaces.api.md

@@ -474,11 +474,11 @@ export interface IUsageError extends IErrorBase {
 // @public
 export const enum LogLevel {
     // (undocumented)
-    default = 10,
+    default = 20,
     // (undocumented)
-    error = 20,
+    error = 30,
     // (undocumented)
-    verbose = 0
+    verbose = 10
 }
 
 // @public

api-report/telemetry-utils.api.md

@@ -273,6 +273,7 @@ export function mixinMonitoringContext<L extends ITelemetryBaseLogger = ITelemet
 
 // @public
 export class MockLogger implements ITelemetryBaseLogger {
+    constructor(minLogLevel?: LogLevel | undefined);
     assertMatch(expectedEvents: Omit<ITelemetryBaseEvent, "category">[], message?: string, inlineDetailsProp?: boolean): void;
     assertMatchAny(expectedEvents: Omit<ITelemetryBaseEvent, "category">[], message?: string, inlineDetailsProp?: boolean): void;
     assertMatchNone(disallowedEvents: Omit<ITelemetryBaseEvent, "category">[], message?: string, inlineDetailsProp?: boolean): void;
@@ -285,6 +286,8 @@ export class MockLogger implements ITelemetryBaseLogger {
     matchEvents(expectedEvents: Omit<ITelemetryBaseEvent, "category">[], inlineDetailsProp?: boolean): boolean;
     matchEventStrict(expectedEvents: Omit<ITelemetryBaseEvent, "category">[], inlineDetailsProp?: boolean): boolean;
     // (undocumented)
+    readonly minLogLevel?: LogLevel | undefined;
+    // (undocumented)
     send(event: ITelemetryBaseEvent): void;
     // (undocumented)
     toTelemetryLogger(): ITelemetryLoggerExt;

packages/common/core-interfaces/src/logger.ts

@@ -49,9 +49,9 @@ export interface ITelemetryBaseEvent extends ITelemetryProperties {
  * Enum to specify a level to the log to filter out logs based on the level.
  */
 export const enum LogLevel {
-	verbose = 0, // To log any verbose event for example when you are debugging something.
-	default = 10, // Default log level
-	error = 20, // To log errors.
+	verbose = 10, // To log any verbose event for example when you are debugging something.
+	default = 20, // Default log level
+	error = 30, // To log errors.
 }
 
 /**

packages/test/test-service-load/src/runner.ts

@@ -92,12 +92,15 @@ async function main() {
 	// this makes runners repeatable, but ensures each runner
 	// will get its own set of randoms
 	const random = makeRandom(seed, runId);
-	const logger = await createLogger({
-		runId,
-		driverType: driver,
-		driverEndpointName: endpoint,
-		profile: profileName,
-	});
+	const logger = await createLogger(
+		{
+			runId,
+			driverType: driver,
+			driverEndpointName: endpoint,
+			profile: profileName,
+		},
+		random.pick([LogLevel.verbose, LogLevel.default]),
+	);
 
 	// this will enabling capturing the full stack for errors
 	// since this is test capturing the full stack is worth it
@@ -201,7 +204,6 @@ async function runnerProcess(
 		() => new FaultInjectionDocumentServiceFactory(testDriver.createDocumentServiceFactory()),
 	);
 
-	const loggerLogLevelOptions = [LogLevel.verbose, LogLevel.default];
 	let done = false;
 	// Reset the workload once, on the first iteration
 	let reset = true;
@@ -216,8 +218,6 @@ async function runnerProcess(
 			const { documentServiceFactory, headers } = nextFactoryPermutation.value;
 
 			// Construct the loader
-			runConfig.logger.minLogLevel =
-				loggerLogLevelOptions[runConfig.runId % loggerLogLevelOptions.length];
 			runConfig.loaderConfig = loaderOptions[runConfig.runId % loaderOptions.length];
 			runConfig.logger.sendTelemetryEvent({
 				eventName: "RunConfigOptions",

packages/test/test-service-load/src/utils.ts

@@ -40,40 +40,48 @@ import { ILoadTestConfig, ITestConfig } from "./testConfigFile";
 const packageName = `${pkgName}@${pkgVersion}`;
 
 class FileLogger implements ITelemetryBufferedLogger {
-	private static readonly loggerP = new LazyPromise<FileLogger>(async () => {
-		if (process.env.FLUID_TEST_LOGGER_PKG_PATH !== undefined) {
-			await import(process.env.FLUID_TEST_LOGGER_PKG_PATH);
-			const logger = getTestLogger?.();
-			assert(logger !== undefined, "Expected getTestLogger to return something");
-			return new FileLogger(logger);
-		} else {
-			return new FileLogger();
-		}
-	});
+	private static readonly loggerP = (minLogLevel?: LogLevel) =>
+		new LazyPromise<FileLogger>(async () => {
+			if (process.env.FLUID_TEST_LOGGER_PKG_PATH !== undefined) {
+				await import(process.env.FLUID_TEST_LOGGER_PKG_PATH);
+				const logger = getTestLogger?.();
+				assert(logger !== undefined, "Expected getTestLogger to return something");
+				return new FileLogger(logger, minLogLevel);
+			} else {
+				return new FileLogger(undefined, minLogLevel);
+			}
+		});
 
-	public static async createLogger(dimensions: {
-		driverType: string;
-		driverEndpointName: string | undefined;
-		profile: string;
-		runId: number | undefined;
-	}) {
+	public static async createLogger(
+		dimensions: {
+			driverType: string;
+			driverEndpointName: string | undefined;
+			profile: string;
+			runId: number | undefined;
+		},
+		minLogLevel: LogLevel = LogLevel.default,
+	) {
+		const logger = await this.loggerP(minLogLevel);
 		return createChildLogger({
-			logger: await this.loggerP,
+			logger,
 			properties: {
 				all: dimensions,
 			},
 		});
 	}
 
 	public static async flushLogger(runInfo?: { url: string; runId?: number }) {
-		await (await this.loggerP).flush(runInfo);
+		await (await this.loggerP()).flush(runInfo);
 	}
 
 	private error: boolean = false;
 	private readonly schema = new Map<string, number>();
 	private logs: ITelemetryBaseEvent[] = [];
 
-	private constructor(private readonly baseLogger?: ITelemetryBufferedLogger) {}
+	private constructor(
+		private readonly baseLogger?: ITelemetryBufferedLogger,
+		public readonly minLogLevel?: LogLevel,
+	) {}
 
 	async flush(runInfo?: { url: string; runId?: number }): Promise<void> {
 		const baseFlushP = this.baseLogger?.flush();
@@ -174,21 +182,24 @@ export async function initialize(
 		generateConfigurations(seed, optionsOverride?.configurations),
 	);
 
-	const logger = await createLogger({
-		driverType: testDriver.type,
-		driverEndpointName: testDriver.endpointName,
-		profile: profileName,
-		runId: undefined,
-	});
-	logger.minLogLevel = random.pick([LogLevel.verbose, LogLevel.default]);
+	const minLogLevel = random.pick([LogLevel.verbose, LogLevel.default]);
+	const logger = await createLogger(
+		{
+			driverType: testDriver.type,
+			driverEndpointName: testDriver.endpointName,
+			profile: profileName,
+			runId: undefined,
+		},
+		minLogLevel,
+	);
 
 	logger.sendTelemetryEvent({
 		eventName: "RunConfigOptions",
 		details: JSON.stringify({
 			loaderOptions,
 			containerOptions,
 			configurations,
-			logLevel: logger.minLogLevel,
+			logLevel: minLogLevel,
 		}),
 	});
 

packages/utils/telemetry-utils/src/logger.ts

@@ -29,7 +29,6 @@ import {
 	ITelemetryGenericEventExt,
 	ITelemetryLoggerExt,
 	ITelemetryPerformanceEventExt,
-	ITelemetryPropertiesExt,
 	TelemetryEventPropertyTypeExt,
 } from "./telemetryTypes";
 
@@ -424,7 +423,11 @@ export class ChildLogger extends TelemetryLogger {
 		}
 	}
 
-	private shouldFilterOutEvent(event: ITelemetryPropertiesExt, logLevel?: LogLevel): boolean {
+	public get minLogLevel(): LogLevel | undefined {
+		return this.baseLogger.minLogLevel;
+	}
+
+	private shouldFilterOutEvent(event: ITelemetryBaseEvent, 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.
@@ -469,6 +472,9 @@ export function createMultiSinkLogger(props: {
  */
 export class MultiSinkLogger extends TelemetryLogger {
 	protected loggers: ITelemetryBaseLogger[];
+	// This is minimum of minLlogLevel of all loggers.
+	private _minLogLevelOfAllLoggers: LogLevel;
+
 	/**
 	 * Create multiple sink logger (i.e. logger that sends events to multiple sinks)
 	 * @param namespace - Telemetry event name prefix to add to all events
@@ -500,6 +506,22 @@ export class MultiSinkLogger extends TelemetryLogger {
 
 		super(namespace, realProperties);
 		this.loggers = loggers;
+		this._minLogLevelOfAllLoggers = LogLevel.default;
+		this.calculateMinLogLevel();
+	}
+
+	public get minLogLevel(): LogLevel {
+		return this._minLogLevelOfAllLoggers;
+	}
+
+	private calculateMinLogLevel(): void {
+		if (this.loggers.length > 0) {
+			const logLevels: number[] = [];
+			for (const logger of this.loggers) {
+				logLevels.push(logger.minLogLevel ?? LogLevel.default);
+			}
+			this._minLogLevelOfAllLoggers = Math.min(...logLevels);
+		}
 	}
 
 	/**
@@ -509,6 +531,8 @@ export class MultiSinkLogger extends TelemetryLogger {
 	public addLogger(logger?: ITelemetryBaseLogger): void {
 		if (logger !== undefined && logger !== null) {
 			this.loggers.push(logger);
+			// Update in case the logLevel of added logger is less than the current.
+			this.calculateMinLogLevel();
 		}
 	}
 

packages/utils/telemetry-utils/src/mockLogger.ts

@@ -3,7 +3,11 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryBaseEvent, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import {
+	ITelemetryBaseEvent,
+	ITelemetryBaseLogger,
+	LogLevel,
+} from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/common-utils";
 import { ITelemetryLoggerExt, ITelemetryPropertiesExt } from "./telemetryTypes";
 import { createChildLogger } from "./logger";
@@ -15,6 +19,8 @@ import { createChildLogger } from "./logger";
 export class MockLogger implements ITelemetryBaseLogger {
 	events: ITelemetryBaseEvent[] = [];
 
+	constructor(public readonly minLogLevel?: LogLevel) {}
+
 	clear(): void {
 		this.events = [];
 	}

packages/utils/telemetry-utils/src/test/childLogger.spec.ts

@@ -9,7 +9,8 @@ import {
 	ITelemetryBaseLogger,
 	LogLevel,
 } from "@fluidframework/core-interfaces";
-import { ChildLogger, createChildLogger } from "../logger";
+import { ChildLogger, createChildLogger, createMultiSinkLogger } from "../logger";
+import { MockLogger } from "../mockLogger";
 
 describe("ChildLogger", () => {
 	it("Properties & Getters Propagate", () => {
@@ -244,4 +245,29 @@ describe("ChildLogger", () => {
 		childLogger1.send({ category: "generic", eventName: "testEvent" }, LogLevel.verbose);
 		assert(!sent, "event should not be sent");
 	});
+
+	it("should be able to send events correctly according to loglevel if multisink logger is used inside childlogger", () => {
+		let sent = false;
+		const logger1: ITelemetryBaseLogger = {
+			send(event: ITelemetryBaseEvent): void {
+				if (event.eventName !== "testEvent") {
+					throw new Error("unexpected event");
+				}
+				sent = true;
+			},
+			minLogLevel: LogLevel.default,
+		};
+		const multiSinkLogger = createMultiSinkLogger({
+			loggers: [logger1, new MockLogger(LogLevel.error)],
+		});
+		const childLogger1 = createChildLogger({
+			logger: multiSinkLogger,
+		});
+
+		childLogger1.send({ category: "generic", eventName: "testEvent" }, LogLevel.verbose);
+		assert(!sent, "verbose event should not be sent");
+
+		childLogger1.send({ category: "generic", eventName: "testEvent" }, LogLevel.default);
+		assert(sent, "verbose event should be sent");
+	});
 });

packages/utils/telemetry-utils/src/test/config.spec.ts

@@ -4,14 +4,14 @@
  */
 
 import { strict as assert } from "assert";
-import { MockLogger } from "@fluidframework/telemetry-utils-previous";
 import {
 	CachedConfigProvider,
 	ConfigTypes,
 	IConfigProviderBase,
 	inMemoryConfigProvider,
 } from "../config";
 import { TelemetryDataTag } from "../logger";
+import { MockLogger } from "../mockLogger";
 
 const getMockStore = (settings: Record<string, string>): Storage => {
 	const ops: string[] = [];