@fluidframework/telemetry-utils 2.0.0-internal.6.1.1 → 2.0.0-internal.6.3.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,
@@ -70,4 +77,5 @@ export {
 	ITelemetryLoggerExt,
 	ITaggedTelemetryPropertyTypeExt,
 	ITelemetryPropertiesExt,
+	TelemetryEventCategory,
 } from "./telemetryTypes";

package/src/logger.ts

@@ -10,11 +10,12 @@ import {
 	ITelemetryGenericEvent,
 	ITelemetryPerformanceEvent,
 	ITelemetryProperties,
-	TelemetryEventPropertyType,
-	ITaggedTelemetryPropertyType,
-	TelemetryEventCategory,
+	TelemetryBaseEventPropertyType as TelemetryEventPropertyType,
+	LogLevel,
+	Tagged,
+	ITelemetryBaseProperties,
 } from "@fluidframework/core-interfaces";
-import { IsomorphicPerformance, performance } from "@fluidframework/common-utils";
+import { IsomorphicPerformance, performance } from "@fluid-internal/client-utils";
 import { CachedConfigProvider, loggerIsMonitoringContext, mixinMonitoringContext } from "./config";
 import {
 	isILoggingError,
@@ -23,12 +24,12 @@ import {
 	isTaggedTelemetryPropertyValue,
 } from "./errorLogging";
 import {
-	ITaggedTelemetryPropertyTypeExt,
 	ITelemetryEventExt,
 	ITelemetryGenericEventExt,
 	ITelemetryLoggerExt,
 	ITelemetryPerformanceEventExt,
 	TelemetryEventPropertyTypeExt,
+	TelemetryEventCategory,
 } from "./telemetryTypes";
 
 export interface Memory {
@@ -43,13 +44,17 @@ 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",
 }
 
-export type TelemetryEventPropertyTypes = TelemetryEventPropertyType | ITaggedTelemetryPropertyType;
+export type TelemetryEventPropertyTypes = ITelemetryBaseProperties[string];
 
 export interface ITelemetryLoggerPropertyBag {
 	[index: string]: TelemetryEventPropertyTypes | (() => TelemetryEventPropertyTypes);
@@ -65,6 +70,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 +89,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 +104,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 +146,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: typeof LogLevel.verbose | typeof LogLevel.default = LogLevel.default,
+	): void {
+		this.sendTelemetryEventCore(
+			{ ...event, category: event.category ?? "generic" },
+			error,
+			event.category === "error" ? LogLevel.error : logLevel,
+		);
 	}
 
 	/**
@@ -154,11 +173,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 +190,7 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 			newEvent.duration = formatTick(newEvent.duration);
 		}
 
-		this.send(newEvent);
+		this.send(newEvent, logLevel);
 	}
 
 	/**
@@ -178,7 +199,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 +209,7 @@ export abstract class TelemetryLogger implements ITelemetryLoggerExt {
 				category: "error",
 			},
 			error,
+			LogLevel.error,
 		);
 	}
 
@@ -196,14 +218,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: typeof LogLevel.verbose | typeof 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 +252,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 +289,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 +403,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 +423,27 @@ export class ChildLogger extends TelemetryLogger {
 		}
 	}
 
+	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.
+		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);
 	}
 }
 
@@ -419,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
@@ -438,8 +494,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] };
 					});
 				});
@@ -447,15 +506,33 @@ 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: LogLevel[] = [];
+			for (const logger of this.loggers) {
+				logLevels.push(logger.minLogLevel ?? LogLevel.default);
+			}
+			this._minLogLevelOfAllLoggers = Math.min(...logLevels) as LogLevel;
+		}
 	}
 
 	/**
 	 * 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);
+			// Update in case the logLevel of added logger is less than the current.
+			this.calculateMinLogLevel();
 		}
 	}
 
@@ -466,9 +543,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 +570,7 @@ export class PerformanceEvent {
 		event: ITelemetryGenericEvent,
 		markers?: IPerformanceEventMarkers,
 		recordHeapSize: boolean = false,
-	) {
+	): PerformanceEvent {
 		return new PerformanceEvent(logger, event, markers, recordHeapSize);
 	}
 
@@ -502,7 +579,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 +597,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 +609,7 @@ export class PerformanceEvent {
 		}
 	}
 
-	public get duration() {
+	public get duration(): number {
 		return performance.now() - this.startTime;
 	}
 
@@ -552,6 +629,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 +640,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 +655,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 +664,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 +674,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 +719,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 {}
 }
 
 /**
@@ -662,15 +744,15 @@ function convertToBaseEvent({
 /**
  * Takes in value, and does one of 4 things.
  * if value is of primitive type - returns the original value.
- * If the value is an array of primitives - returns a stringified version of the array.
- * If the value is an object of type ITaggedTelemetryPropertyType - returns the object
+ * If the value is a flat array or object - returns a stringified version of the array/object.
+ * If the value is an object of type Tagged<TelemetryEventPropertyType> - returns the object
  * with its values recursively converted to base property Type.
  * If none of these cases are reached - returns an error string
  * @param x - value passed in to convert to a base property type
  */
 export function convertToBasePropertyType(
-	x: TelemetryEventPropertyTypeExt | ITaggedTelemetryPropertyTypeExt,
-): TelemetryEventPropertyType | ITaggedTelemetryPropertyType {
+	x: TelemetryEventPropertyTypeExt | Tagged<TelemetryEventPropertyTypeExt>,
+): TelemetryEventPropertyType | Tagged<TelemetryEventPropertyType> {
 	return isTaggedTelemetryPropertyValue(x)
 		? {
 				value: convertToBasePropertyTypeUntagged(x.value),
@@ -706,9 +788,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 +806,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);