@fluidframework/container-runtime 2.0.0-internal.5.4.0 → 2.0.0-internal.6.1.0

package/src/containerRuntime.ts

@@ -445,14 +445,6 @@ export interface IContainerRuntimeOptions {
 	readonly enableGroupedBatching?: boolean;
 }
 
-/**
- * The summary tree returned by the root node. It adds state relevant to the root of the tree.
- */
-export interface IRootSummaryTreeWithStats extends ISummaryTreeWithStats {
-	/** The garbage collection stats if GC ran, undefined otherwise. */
-	gcStats?: IGCStats;
-}
-
 /**
  * Accepted header keys for requests coming to the runtime.
  */
@@ -616,6 +608,9 @@ export class ContainerRuntime
 	extends TypedEventEmitter<IContainerRuntimeEvents>
 	implements IContainerRuntime, IRuntime, ISummarizerRuntime, ISummarizerInternalsProvider
 {
+	/**
+	 * @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;
 	}
@@ -743,8 +738,6 @@ export class ContainerRuntime
 				tryFetchBlob<SerializedIdCompressorWithNoSession>(idCompressorBlobName),
 			]);
 
-		const loadExisting = existing === true || context.existing === true;
-
 		// read snapshot blobs needed for BlobManager to load
 		const blobManagerSnapshot = await BlobManager.load(
 			context.baseSnapshot?.trees[blobsTreeName],
@@ -779,9 +772,7 @@ export class ContainerRuntime
 				if (loadSequenceNumberVerification === "log") {
 					logger.sendErrorEvent({ eventName: "SequenceNumberMismatch" }, error);
 				} else {
-					// Call both close and dispose as closeFn implementation will no longer dispose runtime in future
 					context.closeFn(error);
-					context.disposeFn?.(error);
 				}
 			}
 		}
@@ -818,7 +809,7 @@ export class ContainerRuntime
 			},
 			containerScope,
 			logger,
-			loadExisting,
+			existing,
 			blobManagerSnapshot,
 			context.storage,
 			idCompressor,
@@ -1178,13 +1169,7 @@ export class ContainerRuntime
 		// In old loaders without dispose functionality, closeFn is equivalent but will also switch container to readonly mode
 		this.disposeFn = disposeFn ?? closeFn;
 		// In cases of summarizer, we want to dispose instead since consumer doesn't interact with this container
-		this.closeFn = this.isSummarizerClient
-			? this.disposeFn
-			: (error?: ICriticalContainerError) => {
-					closeFn(error);
-					// Also call disposeFn to retain functionality of runtime being disposed on close
-					disposeFn?.(error);
-			  };
+		this.closeFn = this.isSummarizerClient ? this.disposeFn : closeFn;
 
 		this.mc = createChildMonitoringContext({
 			logger: this.logger,
@@ -1693,6 +1678,7 @@ export class ContainerRuntime
 	/**
 	 * Notifies this object about the request made to the container.
 	 * @param request - Request made to the handler.
+	 * @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> {
 		try {
@@ -2274,6 +2260,12 @@ export class ContainerRuntime
 		this.dataStores.processSignal(envelope.address, transformed, local);
 	}
 
+	/**
+	 * Returns the runtime of the data store.
+	 * @param id - Id supplied during creating the data store.
+	 * @param wait - True if you want to wait for it.
+	 * @deprecated - Use getAliasedDataStoreEntryPoint instead to get an aliased data store's entry point.
+	 */
 	public async getRootDataStore(id: string, wait = true): Promise<IFluidRouter> {
 		return this.getRootDataStoreChannel(id, wait);
 	}
@@ -2349,15 +2341,30 @@ export class ContainerRuntime
 		return result;
 	}
 
-	public async createDataStore(pkg: string | string[]): Promise<IDataStore> {
-		const internalId = uuid();
-		return channelToDataStore(
-			await this._createDataStore(pkg, internalId),
-			internalId,
-			this,
-			this.dataStores,
-			this.mc.logger,
-		);
+	/**
+	 * Returns the aliased data store's entryPoint, given the alias.
+	 * @param alias - The alias for the data store.
+	 * @returns - The data store's entry point (IFluidHandle) if it exists and is aliased. Returns undefined if no
+	 * data store has been assigned the given alias.
+	 */
+	public async getAliasedDataStoreEntryPoint(
+		alias: string,
+	): Promise<IFluidHandle<FluidObject> | undefined> {
+		await this.dataStores.waitIfPendingAlias(alias);
+		const internalId = this.internalId(alias);
+		const context = await this.dataStores.getDataStoreIfAvailable(internalId, { wait: false });
+		// If the data store is not available or not an alias, return undefined.
+		if (context === undefined || !(await context.isRoot())) {
+			return undefined;
+		}
+
+		const channel = await context.realize();
+		if (channel.entryPoint === undefined) {
+			throw new UsageError(
+				"entryPoint must be defined on data store runtime for using getAliasedDataStoreEntryPoint",
+			);
+		}
+		return channel.entryPoint;
 	}
 
 	public createDetachedRootDataStore(
@@ -2374,25 +2381,37 @@ export class ContainerRuntime
 		return this.dataStores.createDetachedDataStoreCore(pkg, false);
 	}
 
+	public async createDataStore(pkg: string | string[]): Promise<IDataStore> {
+		const id = uuid();
+		return channelToDataStore(
+			await this.dataStores
+				._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id)
+				.realize(),
+			id,
+			this,
+			this.dataStores,
+			this.mc.logger,
+		);
+	}
+
+	/**
+	 * @deprecated 0.16 Issue #1537, #3631
+	 * @internal
+	 */
 	public async _createDataStoreWithProps(
 		pkg: string | string[],
 		props?: any,
 		id = uuid(),
 	): Promise<IDataStore> {
-		const fluidDataStore = await this.dataStores
-			._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id, props)
-			.realize();
-		return channelToDataStore(fluidDataStore, id, this, this.dataStores, this.mc.logger);
-	}
-
-	private async _createDataStore(
-		pkg: string | string[],
-		id = uuid(),
-		props?: any,
-	): Promise<IFluidDataStoreChannel> {
-		return this.dataStores
-			._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id, props)
-			.realize();
+		return channelToDataStore(
+			await this.dataStores
+				._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id, props)
+				.realize(),
+			id,
+			this,
+			this.dataStores,
+			this.mc.logger,
+		);
 	}
 
 	private canSendOps() {
@@ -2573,7 +2592,7 @@ export class ContainerRuntime
 		fullGC?: boolean;
 		/** True to run GC sweep phase after the mark phase */
 		runSweep?: boolean;
-	}): Promise<IRootSummaryTreeWithStats> {
+	}): Promise<ISummaryTreeWithStats> {
 		this.verifyNotClosed();
 
 		const {
@@ -2596,9 +2615,8 @@ export class ContainerRuntime
 		});
 
 		try {
-			let gcStats: IGCStats | undefined;
 			if (runGC) {
-				gcStats = await this.collectGarbage(
+				await this.collectGarbage(
 					{ logger: summaryLogger, runSweep, fullGC },
 					telemetryContext,
 				);
@@ -2615,7 +2633,7 @@ export class ContainerRuntime
 				0x12f /* "Container Runtime's summarize should always return a tree" */,
 			);
 
-			return { stats, summary, gcStats };
+			return { stats, summary };
 		} finally {
 			this.mc.logger.sendTelemetryEvent({
 				eventName: "SummarizeTelemetry",
@@ -2834,7 +2852,6 @@ export class ContainerRuntime
 			const latestSnapshotInfo = await this.refreshLatestSummaryAckFromServer(
 				createChildLogger({
 					logger: summaryNumberLogger,
-					namespace: undefined,
 					properties: { all: { safeSummary: true } },
 				}),
 			);
@@ -2915,7 +2932,7 @@ export class ContainerRuntime
 			}
 
 			const trace = Trace.start();
-			let summarizeResult: IRootSummaryTreeWithStats;
+			let summarizeResult: ISummaryTreeWithStats;
 			// If the GC state needs to be reset, we need to force a full tree summary and update the unreferenced
 			// state of all the nodes.
 			const forcedFullTree = this.garbageCollector.summaryStateNeedsReset;
@@ -2934,6 +2951,27 @@ export class ContainerRuntime
 					error,
 				};
 			}
+
+			// If validateSummaryBeforeUpload is true, validate that the summary generated by the summarizer nodes is
+			// correct before this summary is uploaded.
+			if (this.validateSummaryBeforeUpload) {
+				const validateResult = this.summarizerNode.validateSummary();
+				if (!validateResult.success) {
+					const { success, ...loggingProps } = validateResult;
+					const error = new RetriableSummaryError(
+						validateResult.reason,
+						validateResult.retryAfterSeconds,
+						{ ...loggingProps },
+					);
+					return {
+						stage: "base",
+						referenceSequenceNumber: summaryRefSeqNum,
+						minimumSequenceNumber,
+						error,
+					};
+				}
+			}
+
 			const { summary: summaryTree, stats: partialStats } = summarizeResult;
 
 			// Now that we have generated the summary, update the message at last summary to the last message processed.
@@ -2970,21 +3008,6 @@ export class ContainerRuntime
 				forcedFullTree,
 			} as const;
 
-			// If validateSummaryBeforeUpload is true, validate that the summary generated by the summarizer nodes is
-			// correct before this summary is uploaded.
-			if (this.validateSummaryBeforeUpload) {
-				const validateResult = this.summarizerNode.validateSummary();
-				if (!validateResult.success) {
-					const { success, ...loggingProps } = validateResult;
-					const error = new RetriableSummaryError(
-						validateResult.reason,
-						validateResult.retryAfterSeconds,
-						{ ...loggingProps },
-					);
-					return { stage: "base", ...generateSummaryData, error };
-				}
-			}
-
 			continueResult = checkContinue();
 			if (!continueResult.continue) {
 				return { stage: "generate", ...generateSummaryData, error: continueResult.error };
@@ -3516,7 +3539,7 @@ export class ContainerRuntime
 						fetchedSnapshotRefSeq: fetchResult.latestSnapshotRefSeq,
 					},
 				);
-				this.closeFn(error);
+				this.disposeFn(error);
 				throw error;
 			}
 
@@ -3678,10 +3701,15 @@ export class ContainerRuntime
 
 	public notifyAttaching() {} // do nothing (deprecated method)
 
-	public getPendingLocalState(): unknown {
+	public async getPendingLocalState(props?: {
+		notifyImminentClosure: boolean;
+	}): Promise<unknown> {
+		this.verifyNotClosed();
+		const waitBlobsToAttach = props?.notifyImminentClosure;
 		if (this._orderSequentiallyCalls !== 0) {
 			throw new UsageError("can't get state during orderSequentially");
 		}
+		const pendingAttachmentBlobs = await this.blobManager.getPendingBlobs(waitBlobsToAttach);
 		// Flush pending batch.
 		// getPendingLocalState() is only exposed through Container.closeAndGetPendingLocalState(), so it's safe
 		// to close current batch.
@@ -3689,7 +3717,7 @@ export class ContainerRuntime
 
 		return {
 			pending: this.pendingStateManager.getLocalState(),
-			pendingAttachmentBlobs: this.blobManager.getPendingBlobs(),
+			pendingAttachmentBlobs,
 		};
 	}
 

package/src/dataStore.ts

@@ -161,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);
 	}
 
@@ -182,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

@@ -849,8 +849,7 @@ export abstract class FluidDataStoreContext
 			await this.realize();
 		}
 		assert(!!this.channel, 0x14c /* "Channel must exist when rebasing ops" */);
-		const innerContents = contents as FluidDataStoreMessage;
-		return this.channel.applyStashedOp(innerContents.content);
+		return this.channel.applyStashedOp(contents);
 	}
 
 	private verifyNotClosed(

package/src/dataStores.ts

@@ -431,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);
@@ -451,104 +450,145 @@ 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(fluidDataStoreId: string, message: IInboundSignalMessage, local: boolean) {
-		const request = { url: fluidDataStoreId };
-		this.validateNotDeleted(fluidDataStoreId, request);
+		this.validateNotDeleted(fluidDataStoreId);
 		const context = this.contexts.get(fluidDataStoreId);
 		if (!context) {
 			// Attach message may not have been processed yet

package/src/deltaManagerProxyBase.ts

@@ -0,0 +1,111 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { EventForwarder } from "@fluidframework/common-utils";
+import {
+	IDeltaManager,
+	IDeltaManagerEvents,
+	IDeltaQueue,
+	IDeltaSender,
+	ReadOnlyInfo,
+} from "@fluidframework/container-definitions";
+import {
+	IClientConfiguration,
+	IClientDetails,
+	IDocumentMessage,
+	ISequencedDocumentMessage,
+	ISignalMessage,
+} from "@fluidframework/protocol-definitions";
+
+/**
+ * Base class for creating proxy to the real delta manager. It implements all required methods on IDeltaManager and
+ * proxy implementations can override specific methods.
+ */
+export class DeltaManagerProxyBase
+	extends EventForwarder<IDeltaManagerEvents>
+	implements IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>
+{
+	public get IDeltaSender(): IDeltaSender {
+		return this;
+	}
+
+	public get inbound(): IDeltaQueue<ISequencedDocumentMessage> {
+		return this.deltaManager.inbound;
+	}
+
+	public get outbound(): IDeltaQueue<IDocumentMessage[]> {
+		return this.deltaManager.outbound;
+	}
+
+	public get inboundSignal(): IDeltaQueue<ISignalMessage> {
+		return this.deltaManager.inboundSignal;
+	}
+
+	public get minimumSequenceNumber(): number {
+		return this.deltaManager.minimumSequenceNumber;
+	}
+
+	public get lastSequenceNumber(): number {
+		return this.deltaManager.lastSequenceNumber;
+	}
+
+	public get lastMessage() {
+		return this.deltaManager.lastMessage;
+	}
+
+	public get lastKnownSeqNumber() {
+		return this.deltaManager.lastKnownSeqNumber;
+	}
+
+	public get initialSequenceNumber(): number {
+		return this.deltaManager.initialSequenceNumber;
+	}
+
+	public get hasCheckpointSequenceNumber() {
+		return this.deltaManager.hasCheckpointSequenceNumber;
+	}
+
+	public get clientDetails(): IClientDetails {
+		return this.deltaManager.clientDetails;
+	}
+
+	public get version(): string {
+		return this.deltaManager.version;
+	}
+
+	public get maxMessageSize(): number {
+		return this.deltaManager.maxMessageSize;
+	}
+
+	public get serviceConfiguration(): IClientConfiguration | undefined {
+		return this.deltaManager.serviceConfiguration;
+	}
+
+	public get active(): boolean {
+		return this.deltaManager.active;
+	}
+
+	public get readOnlyInfo(): ReadOnlyInfo {
+		return this.deltaManager.readOnlyInfo;
+	}
+
+	constructor(
+		protected readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
+	) {
+		super(deltaManager);
+	}
+
+	public dispose(): void {
+		super.dispose();
+	}
+
+	public submitSignal(content: any): void {
+		return this.deltaManager.submitSignal(content);
+	}
+
+	public flush(): void {
+		return this.deltaManager.flush();
+	}
+}

package/src/deltaManagerSummarizerProxy.ts

@@ -4,8 +4,9 @@
  */
 
 import { IDeltaManager, ReadOnlyInfo } from "@fluidframework/container-definitions";
-import { DeltaManagerProxyBase } from "@fluidframework/container-utils";
 import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+
+import { DeltaManagerProxyBase } from "./deltaManagerProxyBase";
 import { summarizerClientType } from "./summary";
 
 /**

package/src/gc/gcTelemetry.ts

@@ -5,7 +5,6 @@
 
 import { ITelemetryGenericEvent } from "@fluidframework/core-interfaces";
 import { IGarbageCollectionData } from "@fluidframework/runtime-definitions";
-import { packagePathToTelemetryProperty } from "@fluidframework/runtime-utils";
 import {
 	generateStack,
 	ITelemetryLoggerExt,
@@ -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,