@fluidframework/container-runtime 2.0.0-dev.5.2.0.169897 → 2.0.0-dev.6.4.0.191258

package/src/dataStore.ts

@@ -3,10 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLoggerExt, TelemetryDataTag } from "@fluidframework/telemetry-utils";
-import { assert, unreachableCase } from "@fluidframework/common-utils";
+import { ITelemetryLoggerExt, TelemetryDataTag, UsageError } from "@fluidframework/telemetry-utils";
+import { assert, unreachableCase } from "@fluidframework/core-utils";
 import { AttachState } from "@fluidframework/container-definitions";
-import { UsageError } from "@fluidframework/container-utils";
 import { FluidObject, IFluidHandle, IRequest, IResponse } from "@fluidframework/core-interfaces";
 import {
 	AliasResult,
@@ -62,6 +61,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 +160,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 +184,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

@@ -3,15 +3,22 @@
  * Licensed under the MIT License.
  */
 
-import { IDisposable, ITelemetryProperties } from "@fluidframework/common-definitions";
-import { FluidObject, IRequest, IResponse, IFluidHandle } from "@fluidframework/core-interfaces";
+import {
+	IDisposable,
+	FluidObject,
+	IRequest,
+	IResponse,
+	IFluidHandle,
+	ITelemetryProperties,
+} from "@fluidframework/core-interfaces";
 import {
 	IAudience,
 	IDeltaManager,
 	AttachState,
 	ILoaderOptions,
 } from "@fluidframework/container-definitions";
-import { assert, Deferred, LazyPromise, TypedEventEmitter } from "@fluidframework/common-utils";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { assert, Deferred, LazyPromise } from "@fluidframework/core-utils";
 import { IDocumentStorageService } from "@fluidframework/driver-definitions";
 import { BlobTreeEntry, readAndParse } from "@fluidframework/driver-utils";
 import {
@@ -47,27 +54,19 @@ 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,
+	DataCorruptionError,
+	DataProcessingError,
+	extractSafePropertiesFromMessage,
 	generateStack,
 	ITelemetryLoggerExt,
-	loggerToMonitoringContext,
 	LoggingError,
 	MonitoringContext,
-	TelemetryDataTag,
+	tagCodeArtifacts,
 	ThresholdCounter,
 } from "@fluidframework/telemetry-utils";
-import {
-	DataCorruptionError,
-	DataProcessingError,
-	extractSafePropertiesFromMessage,
-} from "@fluidframework/container-utils";
-
 import {
 	dataStoreAttributesBlobName,
 	hasIsolatedChannels,
@@ -309,9 +308,18 @@ 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,
+					// The package name is a getter because `this.pkg` may not be initialized during construction.
+					// For data stores loaded from summary, it is initialized during data store realization.
+					fullPackageName: () => this.pkg?.join("/"),
+				}),
+			},
+		});
 		this.thresholdOpsCounter = new ThresholdCounter(
 			FluidDataStoreContext.pendingOpsCountThreshold,
 			this.mc.logger,
@@ -367,10 +375,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> {
@@ -382,15 +393,14 @@ 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.logger.sendErrorEvent({ eventName: "RealizeError" }, errorWrapped);
+				this.mc.logger.sendErrorEvent({ eventName: "RealizeError" }, errorWrapped);
 			});
 		}
 		return this.channelDeferred.promise;
@@ -780,13 +790,9 @@ export abstract class FluidDataStoreContext
 			this.channelDeferred.resolve(this.channel);
 		} catch (error) {
 			this.channelDeferred?.reject(error);
-			this.logger.sendErrorEvent(
+			this.mc.logger.sendErrorEvent(
 				{
 					eventName: "BindRuntimeError",
-					fluidDataStoreId: {
-						value: this.id,
-						tag: TelemetryDataTag.CodeArtifact,
-					},
 				},
 				error,
 			);
@@ -842,8 +848,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(
@@ -910,11 +915,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(),
 		});
@@ -936,8 +936,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

@@ -3,9 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import { IDisposable, ITelemetryBaseLogger } from "@fluidframework/common-definitions";
-import { assert, Deferred, Lazy } from "@fluidframework/common-utils";
-import { ChildLogger, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { assert, Deferred, Lazy } from "@fluidframework/core-utils";
+import { IDisposable, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { createChildLogger, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { FluidDataStoreContext, LocalFluidDataStoreContext } from "./dataStoreContext";
 
 export class DataStoreContexts implements Iterable<[string, FluidDataStoreContext]>, IDisposable {
@@ -45,7 +45,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/dataStoreRegistry.ts

@@ -2,7 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { UsageError } from "@fluidframework/container-utils";
+import { UsageError } from "@fluidframework/telemetry-utils";
 import {
 	FluidDataStoreRegistryEntry,
 	IFluidDataStoreRegistry,

package/src/dataStores.ts

@@ -3,12 +3,12 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryBaseLogger, IDisposable } from "@fluidframework/common-definitions";
 import {
-	DataCorruptionError,
-	extractSafePropertiesFromMessage,
-} from "@fluidframework/container-utils";
-import { IFluidHandle, IRequest } from "@fluidframework/core-interfaces";
+	ITelemetryBaseLogger,
+	IDisposable,
+	IFluidHandle,
+	IRequest,
+} from "@fluidframework/core-interfaces";
 import { FluidObjectHandle } from "@fluidframework/datastore";
 import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
 import {
@@ -38,15 +38,16 @@ import {
 	unpackChildNodesUsedRoutes,
 } from "@fluidframework/runtime-utils";
 import {
-	ChildLogger,
-	loggerToMonitoringContext,
+	createChildMonitoringContext,
+	DataCorruptionError,
+	extractSafePropertiesFromMessage,
 	LoggingError,
 	MonitoringContext,
-	TelemetryDataTag,
+	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
 import { AttachState } from "@fluidframework/container-definitions";
 import { buildSnapshotTree } from "@fluidframework/driver-utils";
-import { assert, Lazy } from "@fluidframework/common-utils";
+import { assert, Lazy } from "@fluidframework/core-utils";
 import { v4 as uuid } from "uuid";
 import { DataStoreContexts } from "./dataStoreContexts";
 import {
@@ -66,7 +67,7 @@ import { StorageServiceWithAttachBlobs } from "./storageServiceWithAttachBlobs";
 import { IDataStoreAliasMessage, isDataStoreAliasMessage } from "./dataStore";
 import {
 	GCNodeType,
-	sweepDatastoresKey,
+	disableDatastoreSweepKey,
 	throwOnTombstoneLoadKey,
 	sendGCUnexpectedUsageEvent,
 } from "./gc";
@@ -132,7 +133,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,
 			"/",
@@ -238,10 +239,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;
@@ -430,8 +428,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);
@@ -450,114 +447,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;
 		}
@@ -566,7 +603,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) {
@@ -574,7 +611,9 @@ export class DataStores implements IDisposable {
 					{
 						eventName: "SetConnectionStateError",
 						clientId,
-						fluidDataStore,
+						...tagCodeArtifacts({
+							fluidDataStoreId,
+						}),
 						details: JSON.stringify({
 							runtimeConnected: this.runtime.connected,
 							connected,
@@ -781,11 +820,11 @@ export class DataStores implements IDisposable {
 	 * Delete data stores and its objects that are sweep ready.
 	 * @param sweepReadyDataStoreRoutes - The routes of data stores and its objects that are sweep ready and should
 	 * be deleted.
-	 * @returns - The routes of data stores and its objects that were deleted.
+	 * @returns The routes of data stores and its objects that were deleted.
 	 */
 	public deleteSweepReadyNodes(sweepReadyDataStoreRoutes: string[]): string[] {
 		// If sweep for data stores is not enabled, return empty list indicating nothing is deleted.
-		if (this.mc.config.getBoolean(sweepDatastoresKey) !== true) {
+		if (this.mc.config.getBoolean(disableDatastoreSweepKey) === true) {
 			return [];
 		}
 		for (const route of sweepReadyDataStoreRoutes) {

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 "@fluid-internal/client-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();
+	}
+}