@fluidframework/container-runtime 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

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, targetClientId?: string): void {
+		return this.deltaManager.submitSignal(content, targetClientId);
+	}
+
+	public flush(): void {
+		return this.deltaManager.flush();
+	}
+}

package/src/deltaManagerSummarizerProxy.ts

@@ -0,0 +1,49 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IDeltaManager, ReadOnlyInfo } from "@fluidframework/container-definitions";
+import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+
+import { DeltaManagerProxyBase } from "./deltaManagerProxyBase";
+import { summarizerClientType } from "./summary";
+
+/**
+ * Proxy to the real IDeltaManager for restricting certain access to layers below container runtime in summarizer clients:
+ * - Summarizer client should be read-only to layers below the container runtime to restrict local changes.
+ * - Summarizer client should not be active to layers below the container runtime to restrict local changes.
+ */
+export class DeltaManagerSummarizerProxy
+	extends DeltaManagerProxyBase
+	implements IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>
+{
+	public get active(): boolean {
+		// Summarize clients should not be active. There shouldn't be any local changes (writes) in the summarizer
+		// except for the SummarizeOp which is generated by the runtime.
+		return !this.isSummarizerClient && this.deltaManager.active;
+	}
+
+	public get readOnlyInfo(): ReadOnlyInfo {
+		// Summarizer clients should be read-only as far as the runtime and layers below are concerned. There shouldn't
+		// be any local changes (writes) in the summarizer except for the summarize op which is generated by the runtime.
+		if (this.isSummarizerClient) {
+			return {
+				readonly: true,
+				forced: false,
+				permissions: undefined,
+				storageOnly: false,
+			};
+		}
+		return this.deltaManager.readOnlyInfo;
+	}
+
+	private readonly isSummarizerClient: boolean;
+
+	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,169 +3,174 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { performance } from "@fluidframework/common-utils";
+import { ITelemetryLoggerExt, formatTick } from "@fluidframework/telemetry-utils";
+import { performance } from "@fluid-internal/client-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
-import {
-    IDocumentMessage,
-    ISequencedDocumentMessage,
-} from "@fluidframework/protocol-definitions";
-
-import {
-    TelemetryLogger,
-} from "@fluidframework/telemetry-utils";
+import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+
 /**
  * DeltaScheduler is responsible for the scheduling of inbound delta queue in cases where there
  * is more than one op a particular run of the queue. It does not schedule if there is just one
  * op or just one batch in the run. It does the following two things:
+ *
  * 1. If the ops have been processed for more than a specific amount of time, it pauses the queue
- *    and calls setTimeout to schedule a resume of the queue. This ensures that we don't block
- *    the JS thread for a long time processing ops synchronously (for example, when catching up
- *    ops right after boot or catching up ops / delayed realizing data stores by summarizer).
+ * and calls setTimeout to schedule a resume of the queue. This ensures that we don't block
+ * the JS thread for a long time processing ops synchronously (for example, when catching up
+ * ops right after boot or catching up ops / delayed realizing data stores by summarizer).
+ *
  * 2. If we scheduled a particular run of the queue, it logs telemetry for the number of ops
- *    processed, the time and number of turns it took to process the ops.
+ * processed, the time and number of turns it took to process the ops.
  */
 export class DeltaScheduler {
-    private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
-    // The time for processing ops in a single turn.
-    public static readonly processingTime = 50;
-
-    // The increase in time for processing ops after each turn.
-    private readonly processingTimeIncrement = 10;
-
-    private processingStartTime: number | undefined;
-    private currentAllowedProcessingTimeForTurn: number = DeltaScheduler.processingTime;
-
-    // This keeps track of the number of times inbound queue has been scheduled. After a particular
-    // count, we log telemetry for the number of ops processed, the time and number of turns it took
-    // to process the ops.
-    private schedulingCount: number = 0;
-
-    private schedulingLog: {
-        opsRemainingToProcess: number;
-        totalProcessingTime: number;
-        numberOfTurns: number;
-        numberOfBatchesProcessed: number;
-        lastSequenceNumber: number;
-        firstSequenceNumber: number;
-        startTime: number;
-    } | undefined;
-
-    constructor(
-        deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
-        private readonly logger: ITelemetryLogger,
-    ) {
-        this.deltaManager = deltaManager;
-        this.deltaManager.inbound.on("idle", () => { this.inboundQueueIdle(); });
-    }
-
-    public batchBegin(message: ISequencedDocumentMessage) {
-        if (!this.processingStartTime) {
-            this.processingStartTime = performance.now();
-        }
-        if (this.schedulingLog === undefined && this.schedulingCount % 500 === 0) {
-            // Every 500th time we are scheduling the inbound queue, we log telemetry for the
-            // number of ops processed, the time and number of turns it took to process the ops.
-            this.schedulingLog = {
-                opsRemainingToProcess: 0,
-                numberOfTurns: 1,
-                totalProcessingTime: 0,
-                numberOfBatchesProcessed: 0,
-                firstSequenceNumber: message.sequenceNumber,
-                lastSequenceNumber: message.sequenceNumber,
-                startTime: performance.now(),
-            };
-        }
-    }
-
-    public batchEnd(message: ISequencedDocumentMessage) {
-        if (this.schedulingLog) {
-            this.schedulingLog.numberOfBatchesProcessed++;
-            this.schedulingLog.lastSequenceNumber = message.sequenceNumber;
-            this.schedulingLog.opsRemainingToProcess = this.deltaManager.inbound.length;
-        }
-
-        if (this.shouldRunScheduler()) {
-            const currentTime = performance.now();
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const elapsedTime = currentTime - this.processingStartTime!;
-            if (elapsedTime > this.currentAllowedProcessingTimeForTurn) {
-                // We have processed ops for more than the total processing time. So, pause the
-                // queue, yield the thread and schedule a resume.
-
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                this.deltaManager.inbound.pause();
-
-                 // Increase the total processing time. Keep doing this after each turn until all the ops have
-                // been processed. This way we keep the responsiveness at the beginning while also making sure
-                // that all the ops process fairly quickly.
-                this.currentAllowedProcessingTimeForTurn += this.processingTimeIncrement;
-
-                // If we are logging the telemetry this time, update the telemetry log object.
-                if (this.schedulingLog) {
-                    this.schedulingLog.numberOfTurns++;
-                    this.schedulingLog.totalProcessingTime += elapsedTime;
-                }
-
-                setTimeout(() => {
-                    if (this.schedulingLog) {
-                        this.logger.sendTelemetryEvent({
-                            eventName: "InboundOpsPartialProcessingTime",
-                            duration: TelemetryLogger.formatTick(elapsedTime),
-                            opsProcessed: this.schedulingLog.lastSequenceNumber -
-                                this.schedulingLog.firstSequenceNumber + 1,
-                            opsRemainingToProcess: this.deltaManager.inbound.length,
-                            processingTime: TelemetryLogger.formatTick(this.schedulingLog.totalProcessingTime),
-                            numberOfTurns: this.schedulingLog.numberOfTurns,
-                            batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
-                            timeToResume: TelemetryLogger.formatTick(performance.now() - currentTime),
-                        });
-                    }
-                    this.deltaManager.inbound.resume();
-                });
-
-                this.processingStartTime = undefined;
-            }
-        }
-    }
-
-    private inboundQueueIdle() {
-        if (this.schedulingLog) {
-            // Add the time taken for processing the final ops to the total processing time in the
-            // telemetry log object.
-            const currentTime = performance.now();
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            this.schedulingLog.totalProcessingTime += currentTime - this.processingStartTime!;
-
-            this.logger.sendTelemetryEvent({
-                eventName: "InboundOpsProcessingTime",
-                opsRemainingToProcess: this.schedulingLog.opsRemainingToProcess,
-                numberOfTurns: this.schedulingLog.numberOfTurns,
-                processingTime: TelemetryLogger.formatTick(this.schedulingLog.totalProcessingTime),
-                opsProcessed: this.schedulingLog.lastSequenceNumber - this.schedulingLog.firstSequenceNumber + 1,
-                batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
-                duration: TelemetryLogger.formatTick(currentTime - this.schedulingLog.startTime),
-                schedulingCount: this.schedulingCount,
-            });
-
-            this.schedulingLog = undefined;
-        }
-
-        // If we scheduled this batch of the inbound queue, increment the counter that tracks the
-        // number of times we have done this.
-        this.schedulingCount++;
-
-        // Reset the processing times.
-        this.processingStartTime = undefined;
-        this.currentAllowedProcessingTimeForTurn = DeltaScheduler.processingTime;
-    }
-
-    /**
-     * This function tells whether we should run the scheduler.
-     */
-    private shouldRunScheduler(): boolean {
-        // If there are still ops in the queue after the one we are processing now, we should
-        // run the scheduler.
-        return this.deltaManager.inbound.length > 0;
-    }
+	private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+	// The time for processing ops in a single turn.
+	public static readonly processingTime = 50;
+
+	// The increase in time for processing ops after each turn.
+	private readonly processingTimeIncrement = 10;
+
+	private processingStartTime: number | undefined;
+	private currentAllowedProcessingTimeForTurn: number = DeltaScheduler.processingTime;
+
+	// This keeps track of the number of times inbound queue has been scheduled. After a particular
+	// count, we log telemetry for the number of ops processed, the time and number of turns it took
+	// to process the ops.
+	private schedulingCount: number = 0;
+
+	private schedulingLog:
+		| {
+				opsRemainingToProcess: number;
+				totalProcessingTime: number;
+				numberOfTurns: number;
+				numberOfBatchesProcessed: number;
+				lastSequenceNumber: number;
+				firstSequenceNumber: number;
+				startTime: number;
+		  }
+		| undefined;
+
+	constructor(
+		deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
+		private readonly logger: ITelemetryLoggerExt,
+	) {
+		this.deltaManager = deltaManager;
+		this.deltaManager.inbound.on("idle", () => {
+			this.inboundQueueIdle();
+		});
+	}
+
+	public batchBegin(message: ISequencedDocumentMessage) {
+		if (!this.processingStartTime) {
+			this.processingStartTime = performance.now();
+		}
+		if (this.schedulingLog === undefined && this.schedulingCount % 500 === 0) {
+			// Every 500th time we are scheduling the inbound queue, we log telemetry for the
+			// number of ops processed, the time and number of turns it took to process the ops.
+			this.schedulingLog = {
+				opsRemainingToProcess: 0,
+				numberOfTurns: 1,
+				totalProcessingTime: 0,
+				numberOfBatchesProcessed: 0,
+				firstSequenceNumber: message.sequenceNumber,
+				lastSequenceNumber: message.sequenceNumber,
+				startTime: performance.now(),
+			};
+		}
+	}
+
+	public batchEnd(message: ISequencedDocumentMessage) {
+		if (this.schedulingLog) {
+			this.schedulingLog.numberOfBatchesProcessed++;
+			this.schedulingLog.lastSequenceNumber = message.sequenceNumber;
+			this.schedulingLog.opsRemainingToProcess = this.deltaManager.inbound.length;
+		}
+
+		if (this.shouldRunScheduler()) {
+			const currentTime = performance.now();
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			const elapsedTime = currentTime - this.processingStartTime!;
+			if (elapsedTime > this.currentAllowedProcessingTimeForTurn) {
+				// We have processed ops for more than the total processing time. So, pause the
+				// queue, yield the thread and schedule a resume.
+
+				// eslint-disable-next-line @typescript-eslint/no-floating-promises
+				this.deltaManager.inbound.pause();
+
+				// Increase the total processing time. Keep doing this after each turn until all the ops have
+				// been processed. This way we keep the responsiveness at the beginning while also making sure
+				// that all the ops process fairly quickly.
+				this.currentAllowedProcessingTimeForTurn += this.processingTimeIncrement;
+
+				// If we are logging the telemetry this time, update the telemetry log object.
+				if (this.schedulingLog) {
+					this.schedulingLog.numberOfTurns++;
+					this.schedulingLog.totalProcessingTime += elapsedTime;
+				}
+
+				setTimeout(() => {
+					if (this.schedulingLog) {
+						this.logger.sendTelemetryEvent({
+							eventName: "InboundOpsPartialProcessingTime",
+							duration: formatTick(elapsedTime),
+							opsProcessed:
+								this.schedulingLog.lastSequenceNumber -
+								this.schedulingLog.firstSequenceNumber +
+								1,
+							opsRemainingToProcess: this.deltaManager.inbound.length,
+							processingTime: formatTick(this.schedulingLog.totalProcessingTime),
+							numberOfTurns: this.schedulingLog.numberOfTurns,
+							batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
+							timeToResume: formatTick(performance.now() - currentTime),
+						});
+					}
+					this.deltaManager.inbound.resume();
+				});
+
+				this.processingStartTime = undefined;
+			}
+		}
+	}
+
+	private inboundQueueIdle() {
+		if (this.schedulingLog) {
+			// Add the time taken for processing the final ops to the total processing time in the
+			// telemetry log object.
+			const currentTime = performance.now();
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			this.schedulingLog.totalProcessingTime += currentTime - this.processingStartTime!;
+
+			this.logger.sendTelemetryEvent({
+				eventName: "InboundOpsProcessingTime",
+				opsRemainingToProcess: this.schedulingLog.opsRemainingToProcess,
+				numberOfTurns: this.schedulingLog.numberOfTurns,
+				processingTime: formatTick(this.schedulingLog.totalProcessingTime),
+				opsProcessed:
+					this.schedulingLog.lastSequenceNumber -
+					this.schedulingLog.firstSequenceNumber +
+					1,
+				batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
+				duration: formatTick(currentTime - this.schedulingLog.startTime),
+				schedulingCount: this.schedulingCount,
+			});
+
+			this.schedulingLog = undefined;
+		}
+
+		// If we scheduled this batch of the inbound queue, increment the counter that tracks the
+		// number of times we have done this.
+		this.schedulingCount++;
+
+		// Reset the processing times.
+		this.processingStartTime = undefined;
+		this.currentAllowedProcessingTimeForTurn = DeltaScheduler.processingTime;
+	}
+
+	/**
+	 * This function tells whether we should run the scheduler.
+	 */
+	private shouldRunScheduler(): boolean {
+		// If there are still ops in the queue after the one we are processing now, we should
+		// run the scheduler.
+		return this.deltaManager.inbound.length > 0;
+	}
 }

package/src/error.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ContainerErrorTypes } from "@fluidframework/container-definitions";
+import { IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils";
+
+/**
+ * Error indicating that a client's session has reached its time limit and is closed.
+ */
+export class ClientSessionExpiredError extends LoggingError implements IFluidErrorBase {
+	readonly errorType = ContainerErrorTypes.clientSessionExpiredError;
+
+	constructor(
+		message: string,
+		readonly expiryMs: number,
+	) {
+		super(message, { timeoutMs: expiryMs });
+	}
+}

package/src/gc/garbageCollection.md

@@ -0,0 +1,106 @@
+# Garbage Collection
+
+Garbage collection (GC) is the process by which Fluid Framework safely delete objects that are not used. The only responsibility of the users of Fluid Framework is to add and remove references to Fluid objects correctly.
+
+## Why have Garbage Collection?
+
+GC reduces the size of the Fluid file at rest, the in-memory content and the summary that is uploaded to / downloaded from the server. It saves COGS on the server and it makes containers load faster as there is less data to download and process.
+
+## What do I need to do?
+
+All Fluid objects that are in use must be properly referenced so that they are not deleted by GC. Similarly, references to all unused Fluid objects should be removed so that they can be deleted by GC. It is the responsibility of the users of Fluid Framework to correctly add and remove references to Fluid objects.
+
+## How do I reference / unreference Fluid objects?
+
+Currently, the only Fluid objects that are eligible for GC are data stores and attachment blobs. The following sections describe how you can mark them as referenced or unreferenced. These sections speak of a "referenced DDS" which refers to a DDS that is created by a referenced data store.
+
+### Data stores
+
+There are 2 ways to reference a data store:
+
+-   Store the data stores's handle (see [IFluidHandle](../../../../../packages/common/core-interfaces/src/handles.ts) in a referenced DDS that supports handle in its data. For example, a data store's handle can be stored in a referenced `SharedMap` DDS.
+
+    Note that storing a handle of any of a data store's DDS will also mark the data store as referenced.
+
+-   Alias the data store. Aliased data stores are rooted in the container, i.e., they are always referenced and cannot be unreferenced later. Aliased data stores can never be deleted so only do so if you want them to live forever.
+
+Once there are no more referenced DDSes in the container containing a handle to a particular data store, that data store is unreferenced and is eligible for GC.
+
+> Note: There should be at least one aliased data store with at least one DDS in a container. This is the starting point for GC to look for other referenced objects in the container.
+
+### Attachment blobs
+
+The only way to reference an attachment blob is to store its IFluidHandle in a referenced DDS similar to data stores.
+
+Once there are no more referenced DDSes in the container containing a handle to a particular attachment blob, that attachment blob is unreferenced and is eligible for GC.
+
+## GC algorithm
+
+The GC algorithm runs in two phases:
+
+### Mark phase
+
+In this phase, the GC algorithm identifies all Fluid objects that are unreferenced and marks them as such:
+
+1. It starts at the root (aliased) data stores and marks them and all their DDSes as referenced.
+2. It recursively finds the handles stored in referenced DDSes and marks the objects corresponding to the handles as referenced until is has scanned all objects.
+3. All the objects in the system that are not marked as referenced are marked as unreferenced. The unreferenced state of the object and timestamp of when it is unreferenced is added to the summary. The timestamp is used to determine how long the object has been unreferenced for and is used for the sweep phase.
+
+Mark phase is enabled by default for a container. It is enabled during creation of the container runtime and remains enabled throughout its lifetime. Basically, this setting is persisted in the summary and cannot be changed.
+
+### Sweep phase
+
+In this phase, the GC algorithm deletes any Fluid object that has been unreferenced for a sufficient time to guarantee
+they could never be referenced again by any active clients, i.e., clients that have the object in memory and could reference it again.
+The Fluid Runtime enforces a maximum session length (configurable) in order to guarantee all in-memory objects are cleared before
+it concludes an object is safe to delete.
+
+GC sweep phase runs in two stages:
+
+-   The first stage is the "Tombstone" stage, where objects are marked as Tombstones, meaning GC believes they will
+    never be referenced again and are safe to delete. They are not yet deleted at this point, but any attempt to
+    load them will fail. This way, there's a chance to recover a Tombstoned object in case we detect it's still being used.
+-   The second stage is the "Sweep" or "Delete" stage, where the objects are fully deleted.
+    This occurs after a configurable delay called the "Sweep Grace Period", to give time for application teams
+    to monitor for Tombstone-related errors and react before delete occurs.
+
+## GC Configuration
+
+The default configuration for GC today is:
+
+-   GC Mark Phase is **enabled**, including Tombstone Mode
+-   Session Expiry is **enabled**
+-   The "Tombstone" stage of Sweep Phase is **enabled** (attempting to load a tombstoned object will fail)
+-   The "Delete" stage of Sweep Phase is **disabled**
+    -   Note: Once enabled, Sweep will only run for documents created from that point forward
+
+### Techniques used for configuration
+
+There are two ways to configure the Fluid Framework's GC behavior, referred to by name throughout these documents:
+
+1.  **"GC Options"**: `ContainerRuntime.loadRuntime` takes an options value of type `IContainerRuntimeOptions`.
+    This type includes a sub-object `gcOptions`, for GC-specific options.
+2.  **"Config Settings"**: The `Loader`'s constructor takes in `ILoaderProps`, which includes `configProvider?: IConfigProviderBase`
+    This configProvider can be used to inject config settings.
+
+Typically GC Options are used for more "official" and stable configuration, whereas Config Settings provide a mechanism
+for apps to override settings easily, e.g. by backing their `IConfigProviderBase` with a configuration/flighting service.
+In cases where a behavior is controlled by both a Config Setting and GC Option, you may experiment at first using Config Settings
+and then later update the passed-in GC Options to finalize the configuration in your code.
+
+### Disabling Mark Phase
+
+If you wish to disable Mark Phase for newly-created documents, set the `gcAllowed` GC Option to `false`.
+Note that this will disable GC permanently (including the sweep phase) for the container during its lifetime.
+
+Mark Phase can also be disabled just for the session, among other behaviors,
+covered in the [Advanced Configuration](./gcEarlyAdoption.md#more-advanced-configurations) docs.
+
+### Enabling Sweep Phase
+
+To enable the Sweep Phase for new documents, you must set the `enableGCSweep` GC Option to true.
+
+### More Advanced Configuration
+
+For additional behaviors that can be configured (e.g. for testing), please see these
+[Advanced Configuration](./gcEarlyAdoption.md#more-advanced-configurations) docs.