@fluidframework/container-runtime 2.0.0-internal.5.3.2 → 2.0.0-internal.6.0.0

package/src/dataStore.ts

@@ -62,6 +62,9 @@ class DataStore implements IDataStore {
 	private readonly pendingAliases: Map<string, Promise<AliasResult>>;
 	private aliasResult: Promise<AliasResult> | undefined;
 
+	/**
+	 * {@inheritDoc @fluidframework/runtime-definitions#IDataStore.trySetAlias}
+	 */
 	async trySetAlias(alias: string): Promise<AliasResult> {
 		if (alias.includes("/")) {
 			throw new UsageError(`The alias cannot contain slashes: '${alias}'`);
@@ -158,7 +161,10 @@ class DataStore implements IDataStore {
 		return "Success";
 	}
 
-	async request(request: IRequest): Promise<IResponse> {
+	/**
+	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+	 */
+	public async request(request: IRequest): Promise<IResponse> {
 		return this.fluidDataStoreChannel.request(request);
 	}
 
@@ -179,6 +185,9 @@ class DataStore implements IDataStore {
 		this.pendingAliases = datastores.pendingAliases;
 	}
 
+	/**
+	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+	 */
 	public get IFluidRouter() {
 		return this.fluidDataStoreChannel;
 	}

package/src/dataStoreContext.ts

@@ -54,19 +54,14 @@ import {
 	IIdCompressorCore,
 	VisibilityState,
 } from "@fluidframework/runtime-definitions";
+import { addBlobToSummary, convertSummaryTreeToITree } from "@fluidframework/runtime-utils";
 import {
-	addBlobToSummary,
-	convertSummaryTreeToITree,
-	packagePathToTelemetryProperty,
-} from "@fluidframework/runtime-utils";
-import {
-	ChildLogger,
+	createChildMonitoringContext,
 	generateStack,
 	ITelemetryLoggerExt,
-	loggerToMonitoringContext,
 	LoggingError,
 	MonitoringContext,
-	TelemetryDataTag,
+	tagCodeArtifacts,
 	ThresholdCounter,
 } from "@fluidframework/telemetry-utils";
 import {
@@ -316,9 +311,16 @@ export abstract class FluidDataStoreContext
 			async (fullGC?: boolean) => this.getGCDataInternal(fullGC),
 		);
 
-		this.mc = loggerToMonitoringContext(
-			ChildLogger.create(this.logger, "FluidDataStoreContext"),
-		);
+		this.mc = createChildMonitoringContext({
+			logger: this.logger,
+			namespace: "FluidDataStoreContext",
+			properties: {
+				all: tagCodeArtifacts({
+					fluidDataStoreId: this.id,
+					fullPackageName: this.pkg?.join("/"),
+				}),
+			},
+		});
 		this.thresholdOpsCounter = new ThresholdCounter(
 			FluidDataStoreContext.pendingOpsCountThreshold,
 			this.mc.logger,
@@ -374,10 +376,13 @@ export abstract class FluidDataStoreContext
 		failedPkgPath?: string,
 		fullPackageName?: readonly string[],
 	): never {
-		throw new LoggingError(reason, {
-			failedPkgPath: { value: failedPkgPath, tag: TelemetryDataTag.CodeArtifact },
-			fullPackageName: packagePathToTelemetryProperty(fullPackageName),
-		});
+		throw new LoggingError(
+			reason,
+			tagCodeArtifacts({
+				failedPkgPath,
+				packagePath: fullPackageName?.join("/"),
+			}),
+		);
 	}
 
 	public async realize(): Promise<IFluidDataStoreChannel> {
@@ -389,13 +394,12 @@ export abstract class FluidDataStoreContext
 					error,
 					"realizeFluidDataStoreContext",
 				);
-				errorWrapped.addTelemetryProperties({
-					fluidDataStoreId: {
-						value: this.id,
-						tag: TelemetryDataTag.CodeArtifact,
-					},
-					packageName: packagePathToTelemetryProperty(this.pkg),
-				});
+				errorWrapped.addTelemetryProperties(
+					tagCodeArtifacts({
+						fullPackageName: this.pkg?.join("/"),
+						fluidDataStoreId: this.id,
+					}),
+				);
 				this.channelDeferred?.reject(errorWrapped);
 				this.mc.logger.sendErrorEvent({ eventName: "RealizeError" }, errorWrapped);
 			});
@@ -790,10 +794,6 @@ export abstract class FluidDataStoreContext
 			this.mc.logger.sendErrorEvent(
 				{
 					eventName: "BindRuntimeError",
-					fluidDataStoreId: {
-						value: this.id,
-						tag: TelemetryDataTag.CodeArtifact,
-					},
 				},
 				error,
 			);
@@ -917,11 +917,6 @@ export abstract class FluidDataStoreContext
 		this.mc.logger.sendTelemetryEvent({
 			eventName,
 			type,
-			fluidDataStoreId: {
-				value: this.id,
-				tag: TelemetryDataTag.CodeArtifact,
-			},
-			packageName: packagePathToTelemetryProperty(this.pkg),
 			isSummaryInProgress: this.summarizerNode.isSummaryInProgress?.(),
 			stack: generateStack(),
 		});
@@ -943,8 +938,11 @@ export abstract class FluidDataStoreContext
 			);
 	}
 
-	public async uploadBlob(blob: ArrayBufferLike): Promise<IFluidHandle<ArrayBufferLike>> {
-		return this.containerRuntime.uploadBlob(blob);
+	public async uploadBlob(
+		blob: ArrayBufferLike,
+		signal?: AbortSignal,
+	): Promise<IFluidHandle<ArrayBufferLike>> {
+		return this.containerRuntime.uploadBlob(blob, signal);
 	}
 }
 

package/src/dataStoreContexts.ts

@@ -7,7 +7,7 @@ import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import { assert, Deferred } from "@fluidframework/common-utils";
 import { Lazy } from "@fluidframework/core-utils";
 import { IDisposable } from "@fluidframework/core-interfaces";
-import { ChildLogger, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { createChildLogger, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { FluidDataStoreContext, LocalFluidDataStoreContext } from "./dataStoreContext";
 
 export class DataStoreContexts implements Iterable<[string, FluidDataStoreContext]>, IDisposable {
@@ -47,7 +47,7 @@ export class DataStoreContexts implements Iterable<[string, FluidDataStoreContex
 	private readonly _logger: ITelemetryLoggerExt;
 
 	constructor(baseLogger: ITelemetryBaseLogger) {
-		this._logger = ChildLogger.create(baseLogger);
+		this._logger = createChildLogger({ logger: baseLogger });
 	}
 
 	[Symbol.iterator](): Iterator<[string, FluidDataStoreContext]> {

package/src/dataStores.ts

@@ -42,11 +42,10 @@ import {
 	unpackChildNodesUsedRoutes,
 } from "@fluidframework/runtime-utils";
 import {
-	ChildLogger,
-	loggerToMonitoringContext,
 	LoggingError,
 	MonitoringContext,
-	TelemetryDataTag,
+	createChildMonitoringContext,
+	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
 import { AttachState } from "@fluidframework/container-definitions";
 import { buildSnapshotTree } from "@fluidframework/driver-utils";
@@ -137,7 +136,7 @@ export class DataStores implements IDisposable {
 		private readonly aliasMap: Map<string, string>,
 		private readonly contexts: DataStoreContexts = new DataStoreContexts(baseLogger),
 	) {
-		this.mc = loggerToMonitoringContext(ChildLogger.create(baseLogger));
+		this.mc = createChildMonitoringContext({ logger: baseLogger });
 		this.containerRuntimeHandle = new FluidObjectHandle(
 			this.runtime,
 			"/",
@@ -243,10 +242,7 @@ export class DataStores implements IDisposable {
 				"Duplicate DataStore created with existing id",
 				{
 					...extractSafePropertiesFromMessage(message),
-					dataStoreId: {
-						value: attachMessage.id,
-						tag: TelemetryDataTag.CodeArtifact,
-					},
+					...tagCodeArtifacts({ dataStoreId: attachMessage.id }),
 				},
 			);
 			throw error;
@@ -435,8 +431,7 @@ export class DataStores implements IDisposable {
 	) {
 		const envelope = message.contents as IEnvelope;
 		const transformed = { ...message, contents: envelope.contents };
-		const request = { url: envelope.address };
-		this.validateNotDeleted(envelope.address, request);
+		this.validateNotDeleted(envelope.address);
 		const context = this.contexts.get(envelope.address);
 		assert(!!context, 0x162 /* "There should be a store context for the op" */);
 		context.process(transformed, local, localMessageMetadata);
@@ -455,114 +450,154 @@ export class DataStores implements IDisposable {
 		requestHeaderData: RuntimeHeaderData,
 	): Promise<FluidDataStoreContext> {
 		const headerData = { ...defaultRuntimeHeaderData, ...requestHeaderData };
-		const request = { url: id };
-
-		this.validateNotDeleted(id, request, headerData);
+		this.validateNotDeleted(id, headerData);
 
 		const context = await this.contexts.getBoundOrRemoted(id, headerData.wait);
 		if (context === undefined) {
 			// The requested data store does not exits. Throw a 404 response exception.
+			const request: IRequest = { url: id };
 			throw responseToException(create404Response(request), request);
 		}
 
-		this.validateNotTombstoned(context, request, requestHeaderData);
+		this.validateNotTombstoned(context, requestHeaderData);
 
 		return context;
 	}
 
 	/**
-	 * Validate that the data store had not been deleted by GC.
-	 *
+	 * Returns the data store requested with the given id if available. Otherwise, returns undefined.
+	 */
+	public async getDataStoreIfAvailable(
+		id: string,
+		requestHeaderData: RuntimeHeaderData,
+	): Promise<FluidDataStoreContext | undefined> {
+		// If the data store has been deleted, return undefined.
+		if (this.checkIfDeleted(id, requestHeaderData)) {
+			return undefined;
+		}
+		const headerData = { ...defaultRuntimeHeaderData, ...requestHeaderData };
+		const context = await this.contexts.getBoundOrRemoted(id, headerData.wait);
+		if (context === undefined) {
+			return undefined;
+		}
+		// Check if the data store is tombstoned. If so, we want to log a telemetry event.
+		this.checkIfTombstoned(context, requestHeaderData);
+		return context;
+	}
+
+	/**
+	 * Checks if the data store has been deleted by GC.
 	 * @param id - data store id
 	 * @param request - the request information to log if the validation detects the data store has been deleted
 	 * @param requestHeaderData - the request header information to log if the validation detects the data store has been deleted
+	 * @returns true if the data store is deleted. Otherwise, returns false.
 	 */
-	private validateNotDeleted(
-		id: string,
-		request: IRequest,
-		requestHeaderData?: RuntimeHeaderData,
-	) {
+	private checkIfDeleted(id: string, requestHeaderData?: RuntimeHeaderData) {
 		const dataStoreNodePath = `/${id}`;
-		if (this.isDataStoreDeleted(dataStoreNodePath)) {
-			assert(
-				!this.contexts.has(id),
-				0x570 /* Inconsistent state! GC says the data store is deleted, but the data store is not deleted from the runtime. */,
-			);
+		if (!this.isDataStoreDeleted(dataStoreNodePath)) {
+			return false;
+		}
+		assert(
+			!this.contexts.has(id),
+			0x570 /* Inconsistent state! GC says the data store is deleted, but the data store is not deleted from the runtime. */,
+		);
+		sendGCUnexpectedUsageEvent(
+			this.mc,
+			{
+				eventName: "GC_Deleted_DataStore_Requested",
+				category: "error",
+				isSummarizerClient: this.runtime.clientDetails.type === summarizerClientType,
+				id,
+				headers: JSON.stringify(requestHeaderData),
+				gcTombstoneEnforcementAllowed: this.runtime.gcTombstoneEnforcementAllowed,
+			},
+			undefined /* packagePath */,
+		);
+		return true;
+	}
+
+	/**
+	 * Validate that the data store had not been deleted by GC.
+	 * @param id - data store id
+	 * @param requestHeaderData - the request header information to log if the validation detects the data store has been deleted
+	 */
+	private validateNotDeleted(id: string, requestHeaderData?: RuntimeHeaderData) {
+		if (this.checkIfDeleted(id, requestHeaderData)) {
 			// The requested data store is removed by gc. Create a 404 gc response exception.
-			const error = responseToException(
+			const request: IRequest = { url: id };
+			throw responseToException(
 				createResponseError(404, "DataStore was deleted", request),
 				request,
 			);
-			sendGCUnexpectedUsageEvent(
-				this.mc,
-				{
-					eventName: "GC_Deleted_DataStore_Requested",
-					category: "error",
-					isSummarizerClient: this.runtime.clientDetails.type === summarizerClientType,
-					headers: JSON.stringify(requestHeaderData),
-					gcTombstoneEnforcementAllowed: this.runtime.gcTombstoneEnforcementAllowed,
-				},
-				undefined /** packagePath */,
-				error,
-			);
-			throw error;
 		}
 	}
 
+	/**
+	 * Checks if the data store has not been marked as tombstone by GC or not.
+	 * @param context - the data store context in question
+	 * @param requestHeaderData - the request header information to log if the validation detects the data store has been tombstoned
+	 * @returns true if the data store is tombstoned. Otherwise, returns false.
+	 */
+	private checkIfTombstoned(
+		context: FluidDataStoreContext,
+		requestHeaderData: RuntimeHeaderData,
+	) {
+		if (!context.tombstoned) {
+			return false;
+		}
+		const logErrorEvent = this.throwOnTombstoneLoad && !requestHeaderData.allowTombstone;
+		sendGCUnexpectedUsageEvent(
+			this.mc,
+			{
+				eventName: "GC_Tombstone_DataStore_Requested",
+				category: logErrorEvent ? "error" : "generic",
+				isSummarizerClient: this.runtime.clientDetails.type === summarizerClientType,
+				id: context.id,
+				headers: JSON.stringify(requestHeaderData),
+				gcTombstoneEnforcementAllowed: this.runtime.gcTombstoneEnforcementAllowed,
+			},
+			context.isLoaded ? context.packagePath : undefined,
+		);
+		return true;
+	}
+
 	/**
 	 * Validates that the data store context requested has not been marked as tombstone by GC.
-	 *
 	 * @param context - the data store context in question
 	 * @param request - the request information to log if the validation detects the data store has been tombstoned
-	 * @param headerData - the request header information to log if the validation detects the data store has been tombstoned
+	 * @param requestHeaderData - the request header information to log if the validation detects the data store has been tombstoned
 	 */
 	private validateNotTombstoned(
 		context: FluidDataStoreContext,
-		request: IRequest,
-		headerData: RuntimeHeaderData,
+		requestHeaderData: RuntimeHeaderData,
 	) {
-		if (context.tombstoned) {
-			const shouldFail = this.throwOnTombstoneLoad && !headerData.allowTombstone;
-
+		if (this.checkIfTombstoned(context, requestHeaderData)) {
 			// The requested data store is removed by gc. Create a 404 gc response exception.
+			const request: IRequest = { url: context.id };
 			const error = responseToException(
 				createResponseError(404, "DataStore was deleted", request, {
 					[TombstoneResponseHeaderKey]: true,
 				}),
 				request,
 			);
-			sendGCUnexpectedUsageEvent(
-				this.mc,
-				{
-					eventName: "GC_Tombstone_DataStore_Requested",
-					category: shouldFail ? "error" : "generic",
-					isSummarizerClient: this.runtime.clientDetails.type === summarizerClientType,
-					headers: JSON.stringify(headerData),
-					gcTombstoneEnforcementAllowed: this.runtime.gcTombstoneEnforcementAllowed,
-				},
-				context.isLoaded ? context.packagePath : undefined,
-				error,
-			);
-
-			if (shouldFail) {
+			// Throw an error if configured via options and via request headers.
+			if (this.throwOnTombstoneLoad && !requestHeaderData.allowTombstone) {
 				throw error;
 			}
 		}
 	}
 
-	public processSignal(address: string, message: IInboundSignalMessage, local: boolean) {
-		const request = { url: address };
-		this.validateNotDeleted(address, request);
-		const context = this.contexts.get(address);
+	public processSignal(fluidDataStoreId: string, message: IInboundSignalMessage, local: boolean) {
+		this.validateNotDeleted(fluidDataStoreId);
+		const context = this.contexts.get(fluidDataStoreId);
 		if (!context) {
 			// Attach message may not have been processed yet
 			assert(!local, 0x163 /* "Missing datastore for local signal" */);
 			this.mc.logger.sendTelemetryEvent({
 				eventName: "SignalFluidDataStoreNotFound",
-				fluidDataStoreId: {
-					value: address,
-					tag: TelemetryDataTag.CodeArtifact,
-				},
+				...tagCodeArtifacts({
+					fluidDataStoreId,
+				}),
 			});
 			return;
 		}
@@ -571,7 +606,7 @@ export class DataStores implements IDisposable {
 	}
 
 	public setConnectionState(connected: boolean, clientId?: string) {
-		for (const [fluidDataStore, context] of this.contexts) {
+		for (const [fluidDataStoreId, context] of this.contexts) {
 			try {
 				context.setConnectionState(connected, clientId);
 			} catch (error) {
@@ -579,7 +614,9 @@ export class DataStores implements IDisposable {
 					{
 						eventName: "SetConnectionStateError",
 						clientId,
-						fluidDataStore,
+						...tagCodeArtifacts({
+							fluidDataStoreId,
+						}),
 						details: JSON.stringify({
 							runtimeConnected: this.runtime.connected,
 							connected,

package/src/deltaManagerSummarizerProxy.ts

@@ -41,6 +41,8 @@ export class DeltaManagerSummarizerProxy
 
 	constructor(deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>) {
 		super(deltaManager);
+		// We are expecting this class to have many listeners, so we suppress noisy "MaxListenersExceededWarning" logging.
+		super.setMaxListeners(0);
 		this.isSummarizerClient = this.deltaManager.clientDetails.type === summarizerClientType;
 	}
 }

package/src/deltaScheduler.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLoggerExt, TelemetryLogger } from "@fluidframework/telemetry-utils";
+import { ITelemetryLoggerExt, formatTick } from "@fluidframework/telemetry-utils";
 import { performance } from "@fluidframework/common-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
 import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
@@ -111,20 +111,16 @@ export class DeltaScheduler {
 					if (this.schedulingLog) {
 						this.logger.sendTelemetryEvent({
 							eventName: "InboundOpsPartialProcessingTime",
-							duration: TelemetryLogger.formatTick(elapsedTime),
+							duration: formatTick(elapsedTime),
 							opsProcessed:
 								this.schedulingLog.lastSequenceNumber -
 								this.schedulingLog.firstSequenceNumber +
 								1,
 							opsRemainingToProcess: this.deltaManager.inbound.length,
-							processingTime: TelemetryLogger.formatTick(
-								this.schedulingLog.totalProcessingTime,
-							),
+							processingTime: formatTick(this.schedulingLog.totalProcessingTime),
 							numberOfTurns: this.schedulingLog.numberOfTurns,
 							batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
-							timeToResume: TelemetryLogger.formatTick(
-								performance.now() - currentTime,
-							),
+							timeToResume: formatTick(performance.now() - currentTime),
 						});
 					}
 					this.deltaManager.inbound.resume();
@@ -147,13 +143,13 @@ export class DeltaScheduler {
 				eventName: "InboundOpsProcessingTime",
 				opsRemainingToProcess: this.schedulingLog.opsRemainingToProcess,
 				numberOfTurns: this.schedulingLog.numberOfTurns,
-				processingTime: TelemetryLogger.formatTick(this.schedulingLog.totalProcessingTime),
+				processingTime: formatTick(this.schedulingLog.totalProcessingTime),
 				opsProcessed:
 					this.schedulingLog.lastSequenceNumber -
 					this.schedulingLog.firstSequenceNumber +
 					1,
 				batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
-				duration: TelemetryLogger.formatTick(currentTime - this.schedulingLog.startTime),
+				duration: formatTick(currentTime - this.schedulingLog.startTime),
 				schedulingCount: this.schedulingCount,
 			});
 

package/src/gc/garbageCollection.ts

@@ -16,9 +16,9 @@ import {
 } from "@fluidframework/runtime-definitions";
 import { ReadAndParseBlob } from "@fluidframework/runtime-utils";
 import {
-	ChildLogger,
+	createChildLogger,
+	createChildMonitoringContext,
 	ITelemetryLoggerExt,
-	loggerToMonitoringContext,
 	MonitoringContext,
 	PerformanceEvent,
 } from "@fluidframework/telemetry-utils";
@@ -137,11 +137,13 @@ export class GarbageCollector implements IGarbageCollector {
 		const baseSnapshot = createParams.baseSnapshot;
 		const readAndParseBlob = createParams.readAndParseBlob;
 
-		this.mc = loggerToMonitoringContext(
-			ChildLogger.create(createParams.baseLogger, "GarbageCollector", {
+		this.mc = createChildMonitoringContext({
+			logger: createParams.baseLogger,
+			namespace: "GarbageCollector",
+			properties: {
 				all: { completedGCRuns: () => this.completedRuns },
-			}),
-		);
+			},
+		});
 
 		this.configs = generateGCConfigs(this.mc, createParams);
 
@@ -466,8 +468,11 @@ export class GarbageCollector implements IGarbageCollector {
 		});
 
 		const logger = options.logger
-			? ChildLogger.create(options.logger, undefined, {
-					all: { completedGCRuns: () => this.completedRuns },
+			? createChildLogger({
+					logger: options.logger,
+					properties: {
+						all: { completedGCRuns: () => this.completedRuns },
+					},
 			  })
 			: this.mc.logger;
 

package/src/gc/gcHelpers.ts

@@ -307,6 +307,7 @@ export function trimLeadingAndTrailingSlashes(str: string) {
 
 /**
  * Tags the passed value as a CodeArtifact and returns the tagged value.
+ * @deprecated - Use telemetry-utils tagCodeArtifacts instead
  */
 export function tagAsCodeArtifact(value: string) {
 	return {

package/src/gc/gcTelemetry.ts

@@ -5,11 +5,11 @@
 
 import { ITelemetryGenericEvent } from "@fluidframework/core-interfaces";
 import { IGarbageCollectionData } from "@fluidframework/runtime-definitions";
-import { packagePathToTelemetryProperty } from "@fluidframework/runtime-utils";
 import {
 	generateStack,
 	ITelemetryLoggerExt,
 	MonitoringContext,
+	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
 import { ICreateContainerMetadata } from "../summary";
 import {
@@ -161,7 +161,6 @@ export class GCTelemetryTracker {
 		const { usageType, currentReferenceTimestampMs, packagePath, id, fromId, ...propsToLog } =
 			nodeUsageProps;
 		const eventProps: Omit<IUnreferencedEventProps, "state" | "usageType"> = {
-			id: tagAsCodeArtifact(id),
 			type: nodeType,
 			unrefTime: nodeStateTracker.unreferencedTimestampMs,
 			age:
@@ -171,7 +170,7 @@ export class GCTelemetryTracker {
 				state === UnreferencedState.Inactive
 					? this.configs.inactiveTimeoutMs
 					: this.configs.sweepTimeoutMs,
-			fromId: fromId ? tagAsCodeArtifact(fromId) : undefined,
+			...tagCodeArtifacts({ id, fromId }),
 			...propsToLog,
 			...this.createContainerMetadata,
 		};
@@ -211,7 +210,7 @@ export class GCTelemetryTracker {
 				const { id: taggedId, fromId: taggedFromId, ...otherProps } = eventProps;
 				const event = {
 					eventName: `${state}Object_${nodeUsageProps.usageType}`,
-					pkg: packagePathToTelemetryProperty(nodeUsageProps.packagePath),
+					pkg: tagCodeArtifacts({ pkg: nodeUsageProps.packagePath?.join("/") }).pkg,
 					stack: generateStack(),
 					id: taggedId,
 					fromId: taggedFromId,
@@ -277,8 +276,10 @@ export class GCTelemetryTracker {
 			if (missingExplicitRoutes.length > 0) {
 				logger.sendErrorEvent({
 					eventName: "gcUnknownOutboundReferences",
-					id: tagAsCodeArtifact(nodeId),
-					routes: tagAsCodeArtifact(JSON.stringify(missingExplicitRoutes)),
+					...tagCodeArtifacts({
+						id: nodeId,
+						routes: JSON.stringify(missingExplicitRoutes),
+					}),
 				});
 			}
 		}
@@ -318,8 +319,10 @@ export class GCTelemetryTracker {
 					}),
 					id,
 					fromId,
-					pkg: pkg ? tagAsCodeArtifact(pkg.join("/")) : undefined,
-					fromPkg: fromPkg ? tagAsCodeArtifact(fromPkg.join("/")) : undefined,
+					...tagCodeArtifacts({
+						pkg: pkg?.join("/"),
+						fromPkg: fromPkg?.join("/"),
+					}),
 				};
 
 				if (state === UnreferencedState.Inactive) {
@@ -379,7 +382,7 @@ export class GCTelemetryTracker {
 					lastSummaryTime,
 					...this.createContainerMetadata,
 				}),
-				id: tagAsCodeArtifact(JSON.stringify(deletedNodeIds)),
+				...tagCodeArtifacts({ id: JSON.stringify(deletedNodeIds) }),
 			});
 		}
 	}
@@ -398,7 +401,7 @@ export function sendGCUnexpectedUsageEvent(
 	packagePath: readonly string[] | undefined,
 	error?: unknown,
 ) {
-	event.pkg = packagePathToTelemetryProperty(packagePath);
+	event.pkg = tagCodeArtifacts({ pkg: packagePath?.join("/") })?.pkg;
 	event.tombstoneFlags = JSON.stringify({
 		DisableTombstone: mc.config.getBoolean(disableTombstoneKey),
 		ThrowOnTombstoneUsage: mc.config.getBoolean(throwOnTombstoneUsageKey),

package/src/id-compressor/idCompressor.ts

@@ -5,7 +5,6 @@
 
 /* eslint-disable @typescript-eslint/restrict-plus-operands */
 
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { assert } from "@fluidframework/common-utils";
 import {
 	IIdCompressor,
@@ -31,6 +30,8 @@ import type {
 	VersionedSerializedIdCompressor,
 } from "@fluidframework/runtime-definitions";
 import BTree from "sorted-btree";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { ITelemetryLoggerExt, createChildLogger } from "@fluidframework/telemetry-utils";
 import {
 	hasAtLeastLength,
 	compareFiniteNumbers,
@@ -305,15 +306,15 @@ export class IdCompressor implements IIdCompressorCore, IIdCompressor {
 	private readonly finalIdToCluster: AppendOnlySortedMap<FinalCompressedId, IdCluster> =
 		new AppendOnlySortedMap(compareFiniteNumbers);
 
+	private readonly logger: ITelemetryLoggerExt;
+
 	/**
 	 * @param localSessionId - the `IdCompressor`'s current local session ID.
 	 * {@link generateStableId}.
 	 */
-	public constructor(
-		public readonly localSessionId: SessionId,
-		private readonly logger?: ITelemetryLoggerExt,
-	) {
+	public constructor(public readonly localSessionId: SessionId, logger?: ITelemetryBaseLogger) {
 		this.localSession = this.createSession(localSessionId);
+		this.logger = createChildLogger({ logger });
 	}
 
 	/**