@fluidframework/container-runtime 0.59.2000-63294 → 0.59.3000-66610

package/src/dataStores.ts

@@ -50,6 +50,7 @@ import {
 } from "./dataStoreContext";
 import { IContainerRuntimeMetadata, nonDataStorePaths, rootHasIsolatedChannels } from "./summaryFormat";
 import { IDataStoreAliasMessage, isDataStoreAliasMessage } from "./dataStore";
+import { GCNodeType } from "./garbageCollection";
 
 type PendingAliasResolve = (success: boolean) => void;
 
@@ -272,8 +273,8 @@ export class DataStores implements IDisposable {
             return false;
         }
 
-        const currentContext = this.contexts.get(aliasMessage.internalId);
-        if (currentContext === undefined) {
+        const context = this.contexts.get(aliasMessage.internalId);
+        if (context === undefined) {
             this.logger.sendErrorEvent({
                 eventName: "AliasFluidDataStoreNotFound",
                 fluidDataStoreId: aliasMessage.internalId,
@@ -281,8 +282,15 @@ export class DataStores implements IDisposable {
             return false;
         }
 
-        this.aliasMap.set(aliasMessage.alias, currentContext.id);
-        currentContext.setInMemoryRoot();
+        const handle = new FluidObjectHandle(
+            context,
+            aliasMessage.internalId,
+            this.runtime.IFluidHandleContext,
+        );
+        this.runtime.addedGCOutboundReference(this.containerRuntimeHandle, handle);
+
+        this.aliasMap.set(aliasMessage.alias, context.id);
+        context.setInMemoryRoot();
         return true;
     }
 
@@ -319,8 +327,7 @@ export class DataStores implements IDisposable {
     public createDetachedDataStoreCore(
         pkg: Readonly<string[]>,
         isRoot: boolean,
-        id = uuid()): IFluidDataStoreContextDetached
-    {
+        id = uuid()): IFluidDataStoreContextDetached {
         const context = new LocalDetachedFluidDataStoreContext({
             id,
             pkg,
@@ -363,7 +370,7 @@ export class DataStores implements IDisposable {
         return context;
     }
 
-    public get disposed() {return this.disposeOnce.evaluated;}
+    public get disposed() { return this.disposeOnce.evaluated; }
     public readonly dispose = () => this.disposeOnce.value;
 
     public resubmitDataStoreOp(content: any, localOpMetadata: unknown) {
@@ -421,7 +428,10 @@ export class DataStores implements IDisposable {
             assert(!local, 0x163 /* "Missing datastore for local signal" */);
             this.logger.sendTelemetryEvent({
                 eventName: "SignalFluidDataStoreNotFound",
-                fluidDataStoreId: address,
+                fluidDataStoreId: {
+                    value: address,
+                    tag: TelemetryDataTag.PackageData,
+                },
             });
             return;
         }
@@ -633,14 +643,21 @@ export class DataStores implements IDisposable {
     }
 
     /**
-     * Called by GC to know if a node is a data store or not. Data store ids are of the format "/dataStoreId".
+     * Called by GC to determine if a node is for a data store or for an object within a data store (for e.g. DDS).
+     * @returns the GC node type if the node belongs to a data store or object within data store, undefined otherwise.
      */
-    public isDataStoreNode(nodePath: string): boolean {
+    public getGCNodeType(nodePath: string): GCNodeType | undefined {
         const pathParts = nodePath.split("/");
-        if (pathParts.length === 2 && this.contexts.has(pathParts[1])) {
-            return true;
+        if (!this.contexts.has(pathParts[1])) {
+            return undefined;
+        }
+
+        // Data stores paths are of the format "/dataStoreId".
+        // Sub data store paths are of the format "/dataStoreId/subPath/...".
+        if (pathParts.length === 2) {
+            return GCNodeType.DataStore;
         }
-        return false;
+        return GCNodeType.SubDataStore;
     }
 }
 

package/src/garbageCollection.ts

@@ -6,7 +6,7 @@
 import { ITelemetryLogger, ITelemetryPerformanceEvent } from "@fluidframework/common-definitions";
 import { assert, LazyPromise, Timer } from "@fluidframework/common-utils";
 import { ICriticalContainerError } from "@fluidframework/container-definitions";
-import { ClientSessionExpiredError, DataProcessingError } from "@fluidframework/container-utils";
+import { ClientSessionExpiredError, DataProcessingError, UsageError } from "@fluidframework/container-utils";
 import { IRequestHeader } from "@fluidframework/core-interfaces";
 import {
     cloneGCData,
@@ -46,6 +46,7 @@ import {
     metadataBlobName,
     ReadFluidDataStoreAttributes,
     dataStoreAttributesBlobName,
+    IGCMetadata,
 } from "./summaryFormat";
 
 /** This is the current version of garbage collection. */
@@ -65,7 +66,9 @@ const runSweepKey = "Fluid.GarbageCollection.RunSweep";
 // Feature gate key to write GC data at the root of the summary tree.
 const writeAtRootKey = "Fluid.GarbageCollection.WriteDataAtRoot";
 // Feature gate key to expire a session after a set period of time.
-const runSessionExpiry = "Fluid.GarbageCollection.RunSessionExpiry";
+const runSessionExpiryKey = "Fluid.GarbageCollection.RunSessionExpiry";
+// Feature gate key to disable expiring session after a set period of time, even if expiry value is present
+const disableSessionExpiryKey = "Fluid.GarbageCollection.DisableSessionExpiry";
 // Feature gate key to log error messages if GC reference validation fails.
 const logUnknownOutboundReferencesKey = "Fluid.GarbageCollection.LogUnknownOutboundReferences";
 
@@ -98,9 +101,11 @@ export interface IGCStats {
 export const GCNodeType = {
     // Nodes that are for data stores.
     DataStore: "DataStore",
+    // Nodes that are within a data store. For example, DDS nodes.
+    SubDataStore: "SubDataStore",
     // Nodes that are for attachment blobs, i.e., blobs uploaded via BlobManager.
     Blob: "Blob",
-    // Nodes that are neither data store not blobs. For example, root node and DDS nodes.
+    // Nodes that are neither of the above. For example, root node.
     Other: "Other",
 };
 export type GCNodeType = typeof GCNodeType[keyof typeof GCNodeType];
@@ -138,24 +143,18 @@ export interface IGarbageCollectionRuntime {
 export interface IGarbageCollector {
     /** Tells whether GC should run or not. */
     readonly shouldRunGC: boolean;
-    /** The time in ms to expire a session for a client for gc. */
-    readonly sessionExpiryTimeoutMs: number | undefined;
-    /**
-     * This tracks two things:
-     * 1. Whether GC is enabled - If this is 0, GC is disabled. If this is greater than 0, GC is enabled.
-     * 2. If GC is enabled, the version of GC used to generate the GC data written in a summary.
-     */
-    readonly gcSummaryFeatureVersion: number;
     /** Tells whether the GC state in summary needs to be reset in the next summary. */
     readonly summaryStateNeedsReset: boolean;
     /** Tells whether GC data should be written to the root of the summary tree. */
     readonly writeDataAtRoot: boolean;
     /** Run garbage collection and update the reference / used state of the system. */
     collectGarbage(
-        options: { logger?: ITelemetryLogger, runGC?: boolean, runSweep?: boolean, fullGC?: boolean },
+        options: { logger?: ITelemetryLogger; runGC?: boolean; runSweep?: boolean; fullGC?: boolean; },
     ): Promise<IGCStats>;
     /** Summarizes the GC data and returns it as a summary tree. */
     summarize(): ISummaryTreeWithStats | undefined;
+    /** Returns the garbage collector specific metadata to be written into the summary. */
+    getMetadata(): IGCMetadata;
     /** Returns a map of each node id to its base GC details in the base summary. */
     getBaseGCDetails(): Promise<Map<string, IGarbageCollectionDetailsBase>>;
     /** Called when the latest summary of the system has been refreshed. */
@@ -231,15 +230,15 @@ class UnreferencedStateTracker {
  * its state across summaries.
  *
  * Node - represented as nodeId, it's a node on the GC graph
- * Outbound Route - a path from one node to another node, think `nodeA` -> `nodeB`
+ * Outbound Route - a path from one node to another node, think `nodeA` -\> `nodeB`
  * Graph - all nodes with their respective routes
  *             GC Graph
  *
  *               Node
  *        NodeId = "datastore1"
- *           /             \
+ *           /             \\
  *    OutboundRoute   OutboundRoute
- *         /                 \
+ *         /                 \\
  *       Node               Node
  *  NodeId = "dds1"     NodeId = "dds2"
  */
@@ -268,24 +267,10 @@ export class GarbageCollector implements IGarbageCollector {
         );
     }
 
-    /**
-     * Tells whether GC should be run based on the GC options and local storage flags.
-     */
-    public readonly shouldRunGC: boolean;
-
     /**
      * The time in ms to expire a session for a client for gc.
      */
-    public readonly sessionExpiryTimeoutMs: number | undefined;
-
-    /**
-     * This tracks two things:
-     * 1. Whether GC is enabled - If this is 0, GC is disabled. If this is greater than 0, GC is enabled.
-     * 2. If GC is enabled, the version of GC used to generate the GC data written in a summary.
-     */
-    public get gcSummaryFeatureVersion(): number {
-        return this.gcEnabled ? this.currentGCVersion : 0;
-    }
+    private readonly sessionExpiryTimeoutMs: number | undefined;
 
     /**
      * Tells whether the GC state needs to be reset in the next summary. We need to do this if:
@@ -305,7 +290,23 @@ export class GarbageCollector implements IGarbageCollector {
      * throughout its lifetime.
      */
     private readonly gcEnabled: boolean;
+    /**
+     * Tracks if sweep phase is enabled for this document. This is specified during document creation and doesn't change
+     * throughout its lifetime.
+     */
+    private readonly sweepEnabled: boolean;
+
+    /**
+     * Tracks if GC should run or not. Even if GC is enabled for a document (see gcEnabled), it can be explicitly
+     * disabled via runtime options or feature flags.
+     */
+    public readonly shouldRunGC: boolean;
+    /**
+     * Tracks if sweep phase should run or not. Even if the sweep phase is enabled for a document (see sweepEnabled), it
+     * can be explicitly disabled via feature flags. It also won't run if session expiry is not enabled.
+     */
     private readonly shouldRunSweep: boolean;
+
     private readonly testMode: boolean;
     private readonly mc: MonitoringContext;
 
@@ -377,26 +378,47 @@ export class GarbageCollector implements IGarbageCollector {
 
         let prevSummaryGCVersion: number | undefined;
 
-        // GC can only be enabled during creation. After that, it can never be enabled again. So, for existing
-        // documents, we get this information from the metadata blob. Similarly the session timeout should be
-        // consistent across all clients, thus we grab it as well from the metadata blob, and set it once on creation.
+        /**
+         * The following GC state is enabled during container creation and cannot be changed throughout its lifetime:
+         * 1. Whether running GC mark phase is allowed or not.
+         * 2. Whether running GC sweep phase is allowed or not.
+         * 3. Whether GC session expiry is enabled or not.
+         * For existing containers, we get this information from the metadata blob of its summary.
+         */
         if (existing) {
             prevSummaryGCVersion = getGCVersion(metadata);
             // Existing documents which did not have metadata blob or had GC disabled have version as 0. For all
             // other existing documents, GC is enabled.
             this.gcEnabled = prevSummaryGCVersion > 0;
+            this.sweepEnabled = metadata?.sweepEnabled ?? false;
             this.sessionExpiryTimeoutMs = metadata?.sessionExpiryTimeoutMs;
         } else {
-            // For new documents, GC has to be explicitly enabled via the gcAllowed flag in GC options.
+            // Sweep should not be enabled without enabling GC mark phase. We could silently disable sweep in this
+            // scenario but explicitly failing makes it clearer and promotes correct usage.
+            if (gcOptions.sweepAllowed && !gcOptions.gcAllowed) {
+                throw new UsageError("GC sweep phase cannot be enabled without enabling GC mark phase");
+            }
+
+            // For new documents, GC has to be explicitly enabled via the flags in GC options.
             this.gcEnabled = gcOptions.gcAllowed === true;
+            this.sweepEnabled = gcOptions.sweepAllowed === true;
+
             // Set the Session Expiry only if the flag is enabled or the test option is set.
-            if (this.mc.config.getBoolean(runSessionExpiry) && this.gcEnabled) {
+            if (this.mc.config.getBoolean(runSessionExpiryKey) && this.gcEnabled) {
                 this.sessionExpiryTimeoutMs = defaultSessionExpiryDurationMs;
             }
         }
 
         // If session expiry is enabled, we need to close the container when the timeout expires
-        if (this.sessionExpiryTimeoutMs !== undefined) {
+        if (this.sessionExpiryTimeoutMs !== undefined
+            && this.mc.config.getBoolean(disableSessionExpiryKey) !== true) {
+            // If Test Override config is set, override Session Expiry timeout
+            const overrideSessionExpiryTimeoutMs =
+                this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.SessionExpiryMs");
+            if (overrideSessionExpiryTimeoutMs !== undefined) {
+                this.sessionExpiryTimeoutMs = overrideSessionExpiryTimeoutMs;
+            }
+
             const timeoutMs = this.sessionExpiryTimeoutMs;
             setLongTimeout(timeoutMs,
                 () => {
@@ -411,7 +433,12 @@ export class GarbageCollector implements IGarbageCollector {
         // latest tracked GC version. For new documents, we will be writing the first summary with the current version.
         this.latestSummaryGCVersion = prevSummaryGCVersion ?? this.currentGCVersion;
 
-        // Whether GC should run or not. Can override with localStorage flag.
+        /**
+         * Whether GC should run or not. The following conditions have to be met to run sweep:
+         * 1. GC should be enabled for this container.
+         * 2. GC should not be disabled via disableGC GC option.
+         * These conditions can be overridden via runGCKey feature flag.
+         */
         this.shouldRunGC = this.mc.config.getBoolean(runGCKey) ?? (
             // GC must be enabled for the document.
             this.gcEnabled
@@ -419,11 +446,15 @@ export class GarbageCollector implements IGarbageCollector {
             && !gcOptions.disableGC
         );
 
-        // Whether GC sweep phase should run or not. If this is false, only GC mark phase is run. Can override with
-        // localStorage flag.
-        this.shouldRunSweep = this.shouldRunGC &&
-            (this.mc.config.getBoolean(runSweepKey) ?? gcOptions.runSweep === true)
-            && this.sessionExpiryTimer !== undefined;
+        /**
+         * Whether sweep should run or not. The following conditions have to be met to run sweep:
+         * 1. Overall GC or mark phase must be enabled (this.shouldRunGC).
+         * 2. Session expiry and sweep should be enabled for this container. Without session expiry we cannot safely
+         *    delete unreferenced objects. This condition (#2) can be overridden via runSweepKey feature flag.
+         */
+        this.shouldRunSweep = this.shouldRunGC && (
+            this.mc.config.getBoolean(runSweepKey) ?? (this.sessionExpiryTimeoutMs !== undefined && this.sweepEnabled)
+        );
 
         // Whether we are running in test mode. In this mode, unreferenced nodes are immediately deleted.
         this.testMode = this.mc.config.getBoolean(gcTestModeKey) ?? gcOptions.runGCInTestMode === true;
@@ -514,7 +545,7 @@ export class GarbageCollector implements IGarbageCollector {
                 return;
             }
 
-            const gcNodes: { [ id: string ]: string[] } = {};
+            const gcNodes: { [ id: string ]: string[]; } = {};
             for (const [nodeId, nodeData] of Object.entries(baseState.gcNodes)) {
                 if (nodeData.unreferencedTimestampMs !== undefined) {
                     this.unreferencedNodesState.set(
@@ -539,7 +570,7 @@ export class GarbageCollector implements IGarbageCollector {
                 return new Map();
             }
 
-            const gcNodes: { [ id: string ]: string[] } = {};
+            const gcNodes: { [ id: string ]: string[]; } = {};
             for (const [nodeId, nodeData] of Object.entries(baseState.gcNodes)) {
                 gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
             }
@@ -548,7 +579,7 @@ export class GarbageCollector implements IGarbageCollector {
             // each node in the summary.
             const usedRoutes = runGarbageCollection(
                 gcNodes,
-                [ "/" ],
+                ["/"],
                 this.mc.logger,
             ).referencedNodeIds;
 
@@ -593,11 +624,11 @@ export class GarbageCollector implements IGarbageCollector {
     public async collectGarbage(
         options: {
             /** Logger to use for logging GC events */
-            logger?: ITelemetryLogger,
+            logger?: ITelemetryLogger;
             /** True to run GC sweep phase after the mark phase */
-            runSweep?: boolean,
+            runSweep?: boolean;
             /** True to generate full GC data */
-            fullGC?: boolean,
+            fullGC?: boolean;
         },
     ): Promise<IGCStats> {
         const {
@@ -616,14 +647,14 @@ export class GarbageCollector implements IGarbageCollector {
             const gcData = await this.runtime.getGCData(fullGC);
             const gcResult = runGarbageCollection(
                 gcData.gcNodes,
-                [ "/" ],
+                ["/"],
                 logger,
             );
-            const gcStats = this.generateStatsAndLogEvents(gcResult);
+            const gcStats = this.generateStatsAndLogEvents(gcResult, logger);
 
             // Update the state since the last GC run. There can be nodes that were referenced between the last and
             // the current run. We need to identify than and update their unreferenced state if needed.
-            this.updateStateSinceLastRun(gcData);
+            this.updateStateSinceLastRun(gcData, logger);
 
             // Update the current state of the system based on the GC run.
             const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
@@ -669,6 +700,18 @@ export class GarbageCollector implements IGarbageCollector {
         return builder.getSummaryTree();
     }
 
+    public getMetadata(): IGCMetadata {
+        return {
+            /**
+             * If GC is enabled, the GC data is written using the current GC version and that is the gcFeature that goes
+             * into the metadata blob. If GC is disabled, the gcFeature is 0.
+             */
+            gcFeature: this.gcEnabled ? this.currentGCVersion : 0,
+            sessionExpiryTimeoutMs: this.sessionExpiryTimeoutMs,
+            sweepEnabled: this.sweepEnabled,
+        };
+    }
+
     /**
      * Returns a map of node ids to their base GC details generated from the base summary. This is used by the caller
      * to initialize the GC state of the nodes.
@@ -840,7 +883,7 @@ export class GarbageCollector implements IGarbageCollector {
      * This function identifies nodes that were referenced since last run and removes their unreferenced state, if any.
      * If these nodes are currently unreferenced, they will be assigned new unreferenced state by the current run.
      */
-    private updateStateSinceLastRun(currentGCData: IGarbageCollectionData) {
+    private updateStateSinceLastRun(currentGCData: IGarbageCollectionData, logger: ITelemetryLogger) {
         // If we haven't run GC before there is nothing to do.
         if (this.previousGCDataFromLastRun === undefined) {
             return;
@@ -855,7 +898,7 @@ export class GarbageCollector implements IGarbageCollector {
 
         // The following log will be enabled once this issue is resolved:
         // https://github.com/microsoft/FluidFramework/issues/8878.
-        if(this.mc.config.getBoolean(logUnknownOutboundReferencesKey) === true
+        if (this.mc.config.getBoolean(logUnknownOutboundReferencesKey) === true
             && missingExplicitReferences.length > 0) {
             missingExplicitReferences.forEach((missingExplicitReference) => {
                 const event: ITelemetryPerformanceEvent = {
@@ -863,7 +906,7 @@ export class GarbageCollector implements IGarbageCollector {
                     gcNodeId: missingExplicitReference[0],
                     gcRoutes: JSON.stringify(missingExplicitReference[1]),
                 };
-                this.mc.logger.sendPerformanceEvent(event);
+                logger.sendPerformanceEvent(event);
             });
         }
 
@@ -902,7 +945,7 @@ export class GarbageCollector implements IGarbageCollector {
          * unreferenced, stop tracking them and remove from unreferenced list.
          * Some of these nodes may be unreferenced now and if so, the current run will add unreferenced state for them.
          */
-        const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, ["/"], this.mc.logger);
+        const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, ["/"], logger);
         for (const nodeId of gcResult.referencedNodeIds) {
             const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
             if (nodeStateTracker !== undefined) {
@@ -973,13 +1016,13 @@ export class GarbageCollector implements IGarbageCollector {
      * @param gcResult - The result of a GC run.
      * @returns the GC stats of the GC run.
      */
-    private generateStatsAndLogEvents(gcResult: IGCResult): IGCStats {
+    private generateStatsAndLogEvents(gcResult: IGCResult, logger: ITelemetryLogger): IGCStats {
         // Log pending events for unreferenced nodes after GC has run. We should have the package data available for
         // them now since the GC run should have loaded these nodes.
         let event = this.pendingEventsQueue.shift();
         while (event !== undefined) {
             const pkg = this.getNodePackagePath(event.id);
-            this.mc.logger.sendErrorEvent({
+            logger.sendErrorEvent({
                 ...event,
                 pkg: pkg ? { value: `/${pkg.join("/")}`, tag: TelemetryDataTag.PackageData } : undefined,
             });

package/src/orderedClientElection.ts

@@ -417,8 +417,7 @@ export class OrderedClientElection
             // Note that we allow a summarizer client to supercede an interactive client as elected client.
             if (this._electedClient === undefined || (!electedClientIsSummarizer && newClientIsSummarizer)) {
                 this.tryElectingClient(client, sequenceNumber);
-            }
-            else if (this._electedParent === undefined && !newClientIsSummarizer) {
+            } else if (this._electedParent === undefined && !newClientIsSummarizer) {
                 // This is an odd case. If the _electedClient is set, the _electedParent should be as well.
                 this.tryElectingParent(client, sequenceNumber);
             }
@@ -443,16 +442,14 @@ export class OrderedClientElection
                         throw new UsageError("Elected client should be a summarizer client 1");
                     }
                     this.tryElectingClient(this._electedParent, sequenceNumber);
-                }
-                else {
+                } else {
                     // 2. The _electedClient is an interactive client that has left the quorum.
                     // Automatically shift to next oldest client.
                     const nextClient = this.findFirstEligibleParent(this._electedParent?.youngerClient) ??
                         this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
                     this.tryElectingClient(nextClient, sequenceNumber);
                 }
-            }
-            else if (this._electedParent === client) {
+            } else if (this._electedParent === client) {
                 // Removing the _electedParent (but not _electedClient).
                 // Shift to the next oldest parent, but do not replace the _electedClient,
                 // which is a summarizer that is still doing work.
@@ -478,8 +475,7 @@ export class OrderedClientElection
             this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
         if (this._electedClient === undefined || this._electedClient === this._electedParent) {
             this.tryElectingClient(nextClient, sequenceNumber);
-        }
-        else {
+        } else {
             // The _electedClient is a summarizer and should not be replaced until it leaves the quorum.
             // Changing the _electedParent will stop the summarizer.
             this.tryElectingParent(nextClient, sequenceNumber);
@@ -493,8 +489,7 @@ export class OrderedClientElection
         const firstClient = this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
         if (this._electedClient === undefined || this._electedClient === this._electedParent) {
             this.tryElectingClient(firstClient, sequenceNumber);
-        }
-        else {
+        } else {
             // The _electedClient is a summarizer and should not be replaced until it leaves the quorum.
             // Changing the _electedParent will stop the summarizer.
             this.tryElectingParent(firstClient, sequenceNumber);

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "0.59.2000-63294";
+export const pkgVersion = "0.59.3000-66610";

package/src/pendingStateManager.ts

@@ -114,7 +114,7 @@ export class PendingStateManager implements IDisposable {
                 pendingStates: this.pendingStates.toArray().map(
                     // delete localOpMetadata since it may not be serializable
                     // and will be regenerated by applyStashedOp()
-                    (state) => state.type === "message" ? {...state, localOpMetadata: undefined } : state),
+                    (state) => state.type === "message" ? { ...state, localOpMetadata: undefined } : state),
             };
         }
     }
@@ -288,7 +288,7 @@ export class PendingStateManager implements IDisposable {
         assert(message.type === state.messageType, 0x28c /* "different message type" */);
         assert(message.clientSequenceNumber === state.clientSequenceNumber || !isOriginalClientId,
             0x28d /* "client sequence number doesn't match" */);
-        switch(message.type) {
+        switch (message.type) {
             case ContainerMessageType.Attach:
                 assert(message.contents.id === state.content.id, 0x28e /* "datastore ID doesn't match" */);
                 break;

package/src/runningSummarizer.ts

@@ -261,9 +261,10 @@ export class RunningSummarizer implements IDisposable {
         this.summaryCollection.unsetPendingAckTimerTimeoutCallback();
 
         if (waitStartResult.result === "done" && waitStartResult.value !== undefined) {
-            this.heuristicData.initialize({
+            this.heuristicData.updateWithLastSummaryAckInfo({
                 refSequenceNumber: waitStartResult.value.summaryOp.referenceSequenceNumber,
-                summaryTime: waitStartResult.value.summaryOp.timestamp,
+                // This will be the Summarizer starting point so only use timestamps from client's machine.
+                summaryTime: Date.now(),
                 summarySequenceNumber: waitStartResult.value.summaryOp.sequenceNumber,
             });
         }
@@ -277,7 +278,7 @@ export class RunningSummarizer implements IDisposable {
      * @returns - result of action.
      */
     private async lockedSummaryAction<T>(action: () => Promise<T>) {
-        assert (this.summarizingLock === undefined, 0x25b /* "Caller is responsible for checking lock" */);
+        assert(this.summarizingLock === undefined, 0x25b /* "Caller is responsible for checking lock" */);
 
         const summarizingLock = new Deferred<void>();
         this.summarizingLock = summarizingLock.promise;
@@ -311,8 +312,7 @@ export class RunningSummarizer implements IDisposable {
         summarizeProps: ISummarizeTelemetryProperties,
         options: ISummarizeOptions,
         cancellationToken = this.cancellationToken,
-        resultsBuilder = new SummarizeResultBuilder()): ISummarizeResults
-    {
+        resultsBuilder = new SummarizeResultBuilder()): ISummarizeResults {
         this.lockedSummaryAction(async () => {
             const summarizeResult = this.generator.summarize(
                 summarizeProps,
@@ -334,8 +334,7 @@ export class RunningSummarizer implements IDisposable {
     /** Heuristics summarize attempt. */
     private trySummarize(
         reason: SummarizeReason,
-        cancellationToken = this.cancellationToken): void
-    {
+        cancellationToken = this.cancellationToken): void {
         if (this.summarizingLock !== undefined) {
             // lockedSummaryAction() will retry heuristic-based summary at the end of current attempt
             // if it's still needed
@@ -344,7 +343,7 @@ export class RunningSummarizer implements IDisposable {
         }
 
         this.lockedSummaryAction(async () => {
-            const attempts: (ISummarizeOptions & { delaySeconds?: number })[] = [
+            const attempts: (ISummarizeOptions & { delaySeconds?: number; })[] = [
                 { refreshLatestAck: false, fullTree: false },
                 { refreshLatestAck: true, fullTree: false },
                 { refreshLatestAck: true, fullTree: false, delaySeconds: 2 * 60 },
@@ -379,7 +378,7 @@ export class RunningSummarizer implements IDisposable {
                     this.logger.sendPerformanceEvent({
                         eventName: "SummarizeAttemptDelay",
                         duration: delaySeconds,
-                        reason: overrideDelaySeconds !== undefined ? "nack with retryAfter" : undefined,
+                        summaryNackDelay: overrideDelaySeconds !== undefined,
                         ...summarizeProps,
                     });
                     await delay(delaySeconds * 1000);

package/src/summarizer.ts

@@ -242,6 +242,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
             eventName: "RunningSummarizer",
             onBehalfOf,
             initSummarySeqNumber: this.runtime.deltaManager.initialSequenceNumber,
+            config: JSON.stringify(this.configurationGetter()),
         });
 
         // Summarizing container ID (with clientType === "summarizer")
@@ -359,8 +360,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
             });
 
             return builder.build();
-        }
-        catch (error) {
+        } catch (error) {
             throw SummarizingWarning.wrap(error, false /* logged */, this.logger);
         }
     };

package/src/summarizerHeuristics.ts

@@ -29,7 +29,7 @@ export class SummarizeHeuristicData implements ISummarizeHeuristicData {
         this._lastSuccessfulSummary = { ...attemptBaseline };
     }
 
-    public initialize(lastSummary: Readonly<ISummarizeAttempt>) {
+    public updateWithLastSummaryAckInfo(lastSummary: Readonly<ISummarizeAttempt>) {
         this._lastAttempt = lastSummary;
         this._lastSuccessfulSummary = { ...lastSummary };
     }

package/src/summarizerTypes.ts

@@ -103,16 +103,16 @@ export interface ISummarizerRuntime extends IConnectableRuntime {
 /** Options affecting summarize behavior. */
 export interface ISummarizeOptions {
     /** True to generate the full tree with no handle reuse optimizations; defaults to false */
-    readonly fullTree?: boolean,
+    readonly fullTree?: boolean;
     /** True to ask the server what the latest summary is first; defaults to false */
-    readonly refreshLatestAck?: boolean,
+    readonly refreshLatestAck?: boolean;
 }
 
 export interface ISubmitSummaryOptions extends ISummarizeOptions {
     /** Logger to use for correlated summary events */
-    readonly summaryLogger: ITelemetryLogger,
+    readonly summaryLogger: ITelemetryLogger;
     /** Tells when summary process should be cancelled */
-    readonly cancellationToken: ISummaryCancellationToken,
+    readonly cancellationToken: ISummaryCancellationToken;
 }
 
 export interface IOnDemandSummarizeOptions extends ISummarizeOptions {
@@ -152,6 +152,8 @@ export interface IGeneratedSummaryStats extends ISummaryStats {
     readonly opsSizesSinceLastSummary: number;
     /** Number of non-system ops since the last summary @see isSystemMessage */
     readonly nonSystemOpsSinceLastSummary: number;
+    /** The summary number for a container's summary. Incremented on summaries throughout its lifetime. */
+    readonly summaryNumber: number;
 }
 
 /** Base results for all submitSummary attempts. */
@@ -358,10 +360,10 @@ export interface ISummarizeHeuristicData {
     readonly lastSuccessfulSummary: Readonly<ISummarizeAttempt>;
 
     /**
-     * Initializes lastAttempt and lastSuccessfulAttempt based on the last summary.
+     * Updates lastAttempt and lastSuccessfulAttempt based on the last summary.
      * @param lastSummary - last ack summary
      */
-    initialize(lastSummary: ISummarizeAttempt): void;
+    updateWithLastSummaryAckInfo(lastSummary: ISummarizeAttempt): void;
 
     /**
      * Records a summary attempt. If the attempt was successfully sent,