@fluidframework/container-runtime 2.0.0-dev.1.4.5.105745 → 2.0.0-dev.2.2.0.111723

package/src/gcSweepReadyUsageDetection.ts

@@ -74,16 +74,8 @@ export class SweepReadyUsageDetectionHandler {
         localStorageOverride?: Pick<Storage, "getItem" | "setItem">,
     ) {
         const noopStorage = { getItem: () => null, setItem: () => {} };
-        if (localStorageOverride !== undefined) {
-            this.localStorage = localStorageOverride;
-        } else {
-            try {
-                // localStorage is not defined in Node environment so this throws
-                this.localStorage = localStorage ?? noopStorage;
-            } catch (error) {
-                this.localStorage = noopStorage;
-            }
-        }
+        // localStorage is not defined in Node environment, so fall back to noopStorage if needed.
+        this.localStorage = localStorageOverride ?? globalThis.localStorage ?? noopStorage;
 
         if (this.localStorage === noopStorage) {
             // This means the Skip Closure Period logic will not work.

package/src/index.ts

@@ -23,23 +23,22 @@ export {
     RuntimeHeaders,
     ISummaryConfiguration,
     DefaultSummaryConfiguration,
+    ICompressionRuntimeOptions,
+    CompressionAlgorithms,
 } from "./containerRuntime";
-export { DeltaScheduler } from "./deltaScheduler";
 export { FluidDataStoreRegistry } from "./dataStoreRegistry";
 export {
     gcBlobPrefix,
+    gcTombstoneBlobKey,
     gcTreeKey,
-    IGarbageCollectionRuntime,
     IGCStats,
 } from "./garbageCollection";
 export {
     IPendingFlush,
-    IPendingFlushMode,
     IPendingLocalState,
     IPendingMessage,
     IPendingState,
 } from "./pendingStateManager";
-export { ScheduleManager } from "./scheduleManager";
 export { Summarizer } from "./summarizer";
 export {
     EnqueueSummarizeResult,
@@ -54,6 +53,7 @@ export {
     INackSummaryResult,
     IOnDemandSummarizeOptions,
     IProvideSummarizer,
+    IRefreshSummaryAckOptions,
     ISubmitSummaryOpResult,
     ISubmitSummaryOptions,
     ISummarizeOptions,

package/src/opCompressor.ts

@@ -0,0 +1,59 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { IsoBuffer } from "@fluidframework/common-utils";
+import { ChildLogger } from "@fluidframework/telemetry-utils";
+import { compress } from "lz4js";
+import { BatchMessage } from "./batchManager";
+import { CompressionAlgorithms, ContainerRuntimeMessage } from "./containerRuntime";
+
+/**
+ * Compresses batches of ops. It generates a single compressed op that contains
+ * the contents of each op in the batch. It then submits empty ops for each original
+ * op to reserve sequence numbers.
+ */
+export class OpCompressor {
+    private readonly logger;
+    private compressedBatchCount = 0;
+
+    constructor(logger: ITelemetryLogger) {
+        this.logger = ChildLogger.create(logger, "OpCompressor");
+    }
+
+    public compressBatch(batch: BatchMessage[], originalLength: number): BatchMessage[] {
+        const batchToSend: BatchMessage[] = [];
+        this.compressedBatchCount++;
+        const batchedContents: ContainerRuntimeMessage[] = [];
+        for (const message of batch) {
+            batchedContents.push(message.deserializedContent);
+        }
+
+        const compressionStart = Date.now();
+        const contentsAsBuffer = new TextEncoder().encode(JSON.stringify(batchedContents));
+        const compressedContents = compress(contentsAsBuffer);
+        const compressedContent = IsoBuffer.from(compressedContents).toString("base64");
+        const duration = Date.now() - compressionStart;
+
+        if (originalLength > 200000 || this.compressedBatchCount % 100) {
+            this.logger.sendPerformanceEvent({
+                eventName: "CompressedBatch",
+                duration,
+                sizeBeforeCompression: originalLength,
+                sizeAfterCompression: compressedContent.length,
+            });
+        }
+
+        batchToSend.push({ ...batch[0], contents: JSON.stringify({ packedContents: compressedContent }),
+                           metadata: { ...batch[0].metadata, compressed: true },
+                           compression: CompressionAlgorithms.lz4 });
+
+        for (const message of batch.slice(1)) {
+            batchToSend.push({ ...message, contents: undefined });
+        }
+
+        return batchToSend;
+    }
+}

package/src/opDecompressor.ts

@@ -0,0 +1,82 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { decompress } from "lz4js";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { assert, IsoBuffer, Uint8ArrayToString } from "@fluidframework/common-utils";
+import { CompressionAlgorithms } from ".";
+
+/**
+ * State machine that "unrolls" contents of compressed batches of ops after decompressing them.
+ * This class relies on some implicit contracts defined below:
+ * 1. A compressed batch will have its first message with batch metadata set to true and compressed set to true
+ * 2. Messages in the middle of a compressed batch will have neither batch metadata nor the compression property set
+ * 3. The final message of a batch will have batch metadata set to false
+ * 4. An individually compressed op will have undefined batch metadata and compression set to true
+ */
+export class OpDecompressor {
+    private activeBatch = false;
+    private rootMessageContents: any | undefined;
+    private processedCount = 0;
+
+    public processMessage(message: ISequencedDocumentMessage): ISequencedDocumentMessage {
+        // We're checking for compression = true or top level compression property so
+        // that we can enable compression without waiting on all ordering services
+        // to pick up protocol change. Eventually only the top level property should
+        // be used.
+        if (message.metadata?.batch === true
+            && (message.metadata?.compressed || message.compression !== undefined)) {
+            // Beginning of a compressed batch
+            assert(this.activeBatch === false, "shouldn't have multiple active batches");
+            if (message.compression) {
+                // lz4 is the only supported compression algorithm for now
+                assert(message.compression === CompressionAlgorithms.lz4,
+                        "lz4 is currently the only supported compression algorithm");
+            }
+
+            this.activeBatch = true;
+
+            const contents = IsoBuffer.from(message.contents.packedContents, "base64");
+            const decompressedMessage = decompress(contents);
+            const intoString = Uint8ArrayToString(decompressedMessage);
+            const asObj = JSON.parse(intoString);
+            this.rootMessageContents = asObj;
+
+            return { ...message, contents: this.rootMessageContents[this.processedCount++] };
+        }
+
+        if (this.rootMessageContents !== undefined && message.metadata?.batch === undefined && this.activeBatch) {
+            // Continuation of compressed batch
+            return { ...message, contents: this.rootMessageContents[this.processedCount++] };
+        }
+
+        if (this.rootMessageContents !== undefined && message.metadata?.batch === false) {
+            // End of compressed batch
+            const returnMessage = { ...message,
+                                    contents: this.rootMessageContents[this.processedCount++] };
+
+            this.activeBatch = false;
+            this.rootMessageContents = undefined;
+            this.processedCount = 0;
+
+            return returnMessage;
+        }
+
+        if (message.metadata?.batch === undefined &&
+            (message.metadata?.compressed || message.compression === CompressionAlgorithms.lz4)) {
+            // Single compressed message
+            assert(this.activeBatch === false, "shouldn't receive compressed message in middle of a batch");
+
+            const contents = IsoBuffer.from(message.contents.packedContents, "base64");
+            const decompressedMessage = decompress(contents);
+            const intoString = new TextDecoder().decode(decompressedMessage);
+            const asObj = JSON.parse(intoString);
+
+            return { ...message, contents: asObj[0] };
+        }
+
+        return message;
+    }
+}

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-dev.1.4.5.105745";
+export const pkgVersion = "2.0.0-dev.2.2.0.111723";

package/src/pendingStateManager.ts

@@ -10,7 +10,6 @@ import { DataProcessingError } from "@fluidframework/container-utils";
 import {
     ISequencedDocumentMessage,
 } from "@fluidframework/protocol-definitions";
-import { FlushMode } from "@fluidframework/runtime-definitions";
 import Deque from "double-ended-queue";
 import { ContainerMessageType } from "./containerRuntime";
 import { pkgVersion } from "./packageVersion";
@@ -29,15 +28,6 @@ export interface IPendingMessage {
     opMetadata: Record<string, unknown> | undefined;
 }
 
-/**
- * This represents a FlushMode update and is added to the pending queue when `setFlushMode` is called on the
- * ContainerRuntime and the FlushMode changes.
- */
-export interface IPendingFlushMode {
-    type: "flushMode";
-    flushMode: FlushMode;
-}
-
 /**
  * This represents an explicit flush call and is added to the pending queue when flush is called on the ContainerRuntime
  * to flush pending messages.
@@ -46,7 +36,7 @@ export interface IPendingFlush {
     type: "flush";
 }
 
-export type IPendingState = IPendingMessage | IPendingFlushMode | IPendingFlush;
+export type IPendingState = IPendingMessage | IPendingFlush;
 
 export interface IPendingLocalState {
     /**
@@ -58,8 +48,6 @@ export interface IPendingLocalState {
 export interface IRuntimeStateHandler{
     connected(): boolean;
     clientId(): string | undefined;
-    flushMode(): FlushMode;
-    setFlushMode(mode: FlushMode): void;
     close(error?: ICriticalContainerError): void;
     applyStashedOp: (type: ContainerMessageType, content: ISequencedDocumentMessage) => Promise<unknown>;
     flush(): void;
@@ -68,13 +56,18 @@ export interface IRuntimeStateHandler{
         content: any,
         localOpMetadata: unknown,
         opMetadata: Record<string, unknown> | undefined): void;
+    rollback(
+        type: ContainerMessageType,
+        content: any,
+        localOpMetadata: unknown): void;
+    orderSequentially(callback: () => void): void;
 }
 
 /**
  * PendingStateManager is responsible for maintaining the messages that have not been sent or have not yet been
  * acknowledged by the server. It also maintains the batch information for both automatically and manually flushed
  * batches along with the messages.
- * When the Container reconnects, it replays the pending states, which includes setting the FlushMode, manual flushing
+ * When the Container reconnects, it replays the pending states, which includes manual flushing
  * of messages and triggering resubmission of unacked ops.
  *
  * It verifies that all the ops are acked, are received in the right order and batch information is correct.
@@ -100,13 +93,6 @@ export class PendingStateManager implements IDisposable {
     // the correct batch metadata.
     private pendingBatchBeginMessage: ISequencedDocumentMessage | undefined;
 
-    /**
-     * This tracks the flush mode for the next message in the pending state queue. When replaying messages, we need to
-     * first set the flush mode to this value and then send ops. It is important to do this info because the flush
-     * mode could have been updated.
-     */
-    private flushModeForNextMessage: FlushMode;
-
     private clientId: string | undefined;
 
     /**
@@ -131,13 +117,9 @@ export class PendingStateManager implements IDisposable {
 
     constructor(
         private readonly stateHandler: IRuntimeStateHandler,
-        initialFlushMode: FlushMode,
         initialLocalState: IPendingLocalState | undefined,
     ) {
         this.initialStates = new Deque<IPendingState>(initialLocalState?.pendingStates ?? []);
-
-        this.flushModeForNextMessage = initialFlushMode;
-        this.onFlushModeUpdated(initialFlushMode);
     }
 
     public get disposed() { return this.disposeOnce.evaluated; }
@@ -174,24 +156,10 @@ export class PendingStateManager implements IDisposable {
         this._pendingMessagesCount++;
     }
 
-    /**
-     * Called when the FlushMode is updated. Adds the FlushMode to the pending state queue.
-     * @param flushMode - The flushMode that was updated.
-     */
-    public onFlushModeUpdated(flushMode: FlushMode) {
-        this.pendingStates.push({ type: "flushMode", flushMode });
-    }
-
     /**
      * Called when flush() is called on the ContainerRuntime to manually flush messages.
      */
     public onFlush() {
-        // If the FlushMode is Immediate, we don't need to track an explicit flush call because every message is
-        // automatically flushed. So, flush is a no-op.
-        if (this.stateHandler.flushMode() === FlushMode.Immediate) {
-            return;
-        }
-
         // If the previous state is not a message, flush is a no-op.
         const previousState = this.pendingStates.peekBack();
         if (previousState?.type !== "message") {
@@ -279,11 +247,6 @@ export class PendingStateManager implements IDisposable {
      * @param message - The message that is being processed.
      */
     private maybeProcessBatchBegin(message: ISequencedDocumentMessage) {
-        // Tracks the last FlushMode that was set before this message was sent.
-        let pendingFlushMode: FlushMode | undefined;
-        // Tracks whether a flush was called before this message was sent.
-        let pendingFlush: boolean = false;
-
         /**
          * We are checking if the next message is the start of a batch. It can happen in the following scenarios:
          *
@@ -295,34 +258,12 @@ export class PendingStateManager implements IDisposable {
          * Keep reading pending states from the queue until we encounter a message. It's possible that the FlushMode was
          * updated a bunch of times without sending any messages.
          */
-        let nextPendingState = this.peekNextPendingState();
-        while (nextPendingState.type !== "message") {
-            if (nextPendingState.type === "flushMode") {
-                pendingFlushMode = nextPendingState.flushMode;
-            }
-            if (nextPendingState.type === "flush") {
-                pendingFlush = true;
-            }
+        while (this.peekNextPendingState().type !== "message") {
             this.pendingStates.shift();
-            nextPendingState = this.peekNextPendingState();
         }
 
-        if (pendingFlushMode !== undefined) {
-            this.flushModeForNextMessage = pendingFlushMode;
-        }
-
-        // If the FlushMode was set to Immediate before this message was sent, this message won't be a batch message
-        // because in Immediate mode, every message is flushed individually.
-        if (pendingFlushMode === FlushMode.Immediate) {
-            return;
-        }
-
-        /**
-         * This message is the first in a batch if before it was sent either the FlushMode was set to TurnBased or there
-         * was an explicit flush call. Note that a flush call is tracked only in TurnBased mode and it indicates the end
-         * of one batch and beginning of another.
-         */
-        if (pendingFlushMode === FlushMode.TurnBased || pendingFlush) {
+        // This message is the first in a batch if the "batch" property on the metadata is set to true
+        if (message.metadata?.batch) {
             // We should not already be processing a batch and there should be no pending batch begin message.
             assert(!this.isProcessingBatch && this.pendingBatchBeginMessage === undefined,
                 0x16b /* "The pending batch state indicates we are already processing a batch" */);
@@ -347,16 +288,6 @@ export class PendingStateManager implements IDisposable {
             return;
         }
 
-        /**
-         * We are in the middle of processing a batch. The batch ends when we see an explicit flush. We should never see
-         * a FlushMode before flush. This is true because we track batches only when FlushMode is TurnBased and in this
-         * mode, a batch ends either by calling flush or by changing the mode to Immediate which also triggers a flush.
-         */
-        assert(
-            nextPendingState.type !== "flushMode",
-            0x2bd /* "We should not see a pending FlushMode until we see a flush when processing a batch" */,
-        );
-
         // There should be a pending batch begin message.
         assert(this.pendingBatchBeginMessage !== undefined, 0x16d /* "There is no pending batch begin message" */);
 
@@ -406,7 +337,7 @@ export class PendingStateManager implements IDisposable {
 
     /**
      * Called when the Container's connection state changes. If the Container gets connected, it replays all the pending
-     * states in its queue. This includes setting the FlushMode and triggering resubmission of unacked ops.
+     * states in its queue. This includes triggering resubmission of unacked ops.
      */
     public replayPendingStates() {
         assert(this.stateHandler.connected(), 0x172 /* "The connection state is not consistent with the runtime" */);
@@ -426,12 +357,7 @@ export class PendingStateManager implements IDisposable {
         // Reset the pending message count because all these messages will be removed from the queue.
         this._pendingMessagesCount = 0;
 
-        // Save the current FlushMode so that we can revert it back after replaying the states.
-        const savedFlushMode = this.stateHandler.flushMode();
-
-        // Set the flush mode for the next message. This step is important because the flush mode may have been changed
-        // after the next pending message was sent.
-        this.stateHandler.setFlushMode(this.flushModeForNextMessage);
+        const messageBatchQueue = new Deque<IPendingMessage>();
 
         // Process exactly `pendingStatesCount` items in the queue as it represents the number of states that were
         // pending when we connected. This is important because the `reSubmitFn` might add more items in the queue
@@ -441,16 +367,43 @@ export class PendingStateManager implements IDisposable {
             const pendingState = this.pendingStates.shift()!;
             switch (pendingState.type) {
                 case "message":
-                    this.stateHandler.reSubmit(
-                        pendingState.messageType,
-                        pendingState.content,
-                        pendingState.localOpMetadata,
-                        pendingState.opMetadata);
-                    break;
-                case "flushMode":
-                    this.stateHandler.setFlushMode(pendingState.flushMode);
+                    assert(pendingState.opMetadata?.batch !== false || messageBatchQueue.length > 0,
+                        0x41b /* We cannot process batches in chunks */);
+                    /**
+                     * We want to ensure grouped messages get processed in a batch.
+                     * Note: It is not possible for the PendingStateManager to receive a partially acked batch. It will
+                     * either receive the whole batch ack or nothing at all.
+                     */
+                    if (messageBatchQueue.length > 0 || pendingState.opMetadata?.batch) {
+                        messageBatchQueue.enqueue(pendingState);
+                    } else {
+                        this.stateHandler.reSubmit(
+                            pendingState.messageType,
+                            pendingState.content,
+                            pendingState.localOpMetadata,
+                            pendingState.opMetadata);
+                    }
                     break;
                 case "flush":
+                    /**
+                     * A "flush" call can indicate the end of a batch.
+                     * We can't rely on the "batch" property in the message metadata as it gets
+                     * updated elsewhere and it is not the same object instance that gets updated.
+                     */
+                    if (messageBatchQueue.length > 0) {
+                        this.stateHandler.orderSequentially(() => {
+                            while (messageBatchQueue.length > 0) {
+                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                const message = messageBatchQueue.dequeue()!;
+                                this.stateHandler.reSubmit(
+                                    message.messageType,
+                                    message.content,
+                                    message.localOpMetadata,
+                                    message.opMetadata);
+                            }
+                        });
+                    }
+                    assert(messageBatchQueue.length === 0, 0x41c /* cannot flush in the middle of a batch */);
                     this.stateHandler.flush();
                     break;
                 default:
@@ -459,7 +412,15 @@ export class PendingStateManager implements IDisposable {
             pendingStatesCount--;
         }
 
-        // Revert the FlushMode.
-        this.stateHandler.setFlushMode(savedFlushMode);
+        // There are some cases where ops are stashed but not flushed. We need to ensure they are resubmitted
+        while (messageBatchQueue.length > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const message = messageBatchQueue.dequeue()!;
+            this.stateHandler.reSubmit(
+                message.messageType,
+                message.content,
+                message.localOpMetadata,
+                message.opMetadata);
+        }
     }
 }

package/src/runningSummarizer.ts

@@ -263,9 +263,9 @@ export class RunningSummarizer implements IDisposable {
 
     /**
      * Can the given op trigger a summary?
-     * # Currently only prevents summaries for Summarize and SummaryAck ops
+     * # Currently always prevents summaries for Summarize and SummaryAck/Nack ops
      * @param op - op to check
-     * @returns true if this type of op can trigger a summary
+     * @returns true if this op can trigger a summary
      */
     private opCanTriggerSummary(op: ISequencedDocumentMessage): boolean {
         switch (op.type) {
@@ -274,10 +274,18 @@ export class RunningSummarizer implements IDisposable {
             case MessageType.SummaryNack:
                 return false;
             default:
-                return true;
+                return isRuntimeMessage(op) || this.nonRuntimeOpCanTriggerSummary();
         }
     }
 
+    private nonRuntimeOpCanTriggerSummary(): boolean {
+        // eslint-disable-next-line max-len
+        const opsSinceLastAck = this.heuristicData.lastOpSequenceNumber - this.heuristicData.lastSuccessfulSummary.refSequenceNumber;
+        return this.configuration.state === "enabled"
+            && (this.configuration.nonRuntimeHeuristicThreshold === undefined
+                || this.configuration.nonRuntimeHeuristicThreshold <= opsSinceLastAck);
+    }
+
     public async waitStop(allowLastSummary: boolean): Promise<void> {
         if (this.stopping) {
             return;

package/src/scheduleManager.ts

@@ -221,6 +221,7 @@ class ScheduleManagerCore {
                 length: endBatch - startBatch,
             });
         }
+
         this.deltaManager.inbound.resume();
     }
 

package/src/summarizer.ts

@@ -334,7 +334,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
             const coordinatorCreateP = this.runCoordinatorCreateFn(this.runtime);
 
             coordinatorCreateP.then((runCoordinator) => {
-                // Successully created the cancellation token. Start the summarizer.
+                // Successfully created the cancellation token. Start the summarizer.
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 const startP = this.start(this.runtime.clientId!, runCoordinator);
                 startP.then(async (runningSummarizer) => {
@@ -382,11 +382,11 @@ export class Summarizer extends EventEmitter implements ISummarizer {
                 // executing the refreshLatestSummaryAck.
                 // https://dev.azure.com/fluidframework/internal/_workitems/edit/779
                 await this.runningSummarizer.lockedRefreshSummaryAckAction(async () =>
-                    this.internalsProvider.refreshLatestSummaryAck(
-                        summaryOpHandle,
-                        summaryAckHandle,
-                        refSequenceNumber,
-                        summaryLogger,
+                    this.internalsProvider.refreshLatestSummaryAck({
+                        proposalHandle: summaryOpHandle,
+                        ackHandle: summaryAckHandle,
+                        summaryRefSeq: refSequenceNumber,
+                        summaryLogger },
                     ).catch(async (error) => {
                         // If the error is 404, so maybe the fetched version no longer exists on server. We just
                         // ignore this error in that case, as that means we will have another summaryAck for the

package/src/summarizerClientElection.ts

@@ -77,7 +77,7 @@ export class SummarizerClientElection
                 // Log and elect a new summarizer client.
                 const opsSinceLastReport = sequenceNumber - this.lastReportedSeq;
                 if (opsSinceLastReport > this.maxOpsSinceLastSummary) {
-                    this.logger.sendErrorEvent({
+                    this.logger.sendTelemetryEvent({
                         eventName: "ElectedClientNotSummarizing",
                         electedClientId,
                         lastSummaryAckSeqForClient: this.lastSummaryAckSeqForClient,

package/src/summarizerHeuristics.ts

@@ -119,9 +119,6 @@ export class SummarizeHeuristicRunner implements ISummarizeHeuristicRunner {
     }
 
     public get idleTime(): number {
-        if (this.configuration.idleTime !== undefined) {
-            return this.configuration.idleTime;
-        }
         const maxIdleTime = this.configuration.maxIdleTime;
         const minIdleTime = this.configuration.minIdleTime;
         const weightedNumOfOps = getWeightedNumberOfOps(

package/src/summarizerTypes.ts

@@ -61,12 +61,7 @@ export interface ISummarizerInternalsProvider {
     submitSummary(options: ISubmitSummaryOptions): Promise<SubmitSummaryResult>;
 
     /** Callback whenever a new SummaryAck is received, to update internal tracking state */
-    refreshLatestSummaryAck(
-        proposalHandle: string,
-        ackHandle: string,
-        summaryRefSeq: number,
-        summaryLogger: ITelemetryLogger,
-    ): Promise<void>;
+    refreshLatestSummaryAck(options: IRefreshSummaryAckOptions): Promise<void>;
 }
 
 /**
@@ -114,6 +109,20 @@ export interface ISummarizeOptions {
     readonly refreshLatestAck?: boolean;
 }
 
+/**
+ * Data required to update internal tracking state after receiving a Summary Ack.
+ */
+ export interface IRefreshSummaryAckOptions {
+    /** Handle from the ack's summary op. */
+    readonly proposalHandle: string | undefined;
+    /** Handle from the summary ack just received */
+    readonly ackHandle: string;
+    /** Reference sequence number from the ack's summary op */
+    readonly summaryRefSeq: number;
+    /** Telemetry logger to which telemetry events will be forwarded. */
+    readonly summaryLogger: ITelemetryLogger;
+}
+
 export interface ISubmitSummaryOptions extends ISummarizeOptions {
     /** Logger to use for correlated summary events */
     readonly summaryLogger: ITelemetryLogger;
@@ -292,7 +301,11 @@ export type SummarizerStopReason =
      * client to no longer be elected as responsible for summaries. Then it
      * tries to stop its spawned summarizer client.
      */
-    | "parentShouldNotSummarize"
+    | "notElectedParent"
+    /**
+     * We are not already running the summarizer and we are not the current elected client id.
+     */
+    | "notElectedClient"
     /** Summarizer client was disconnected */
     | "summarizerClientDisconnected"
     /* running summarizer threw an exception */

package/src/summaryFormat.ts

@@ -99,14 +99,16 @@ export interface IGCMetadata {
      * - A value greater than 0 means GC is enabled.
      */
     readonly gcFeature?: GCVersion;
-    /** If this is present, the session for this container will expire after this time and the container will close */
-    readonly sessionExpiryTimeoutMs?: number;
     /**
      * Tells whether the GC sweep phase is enabled for this container.
      * - True means sweep phase is enabled.
      * - False means sweep phase is disabled. If GC is disabled as per gcFeature, sweep is also disabled.
      */
     readonly sweepEnabled?: boolean;
+    /** If this is present, the session for this container will expire after this time and the container will close */
+    readonly sessionExpiryTimeoutMs?: number;
+    /** How long to wait after an object is unreferenced before deleting it via GC Sweep */
+    readonly sweepTimeoutMs?: number;
 }
 
 /** The properties of an ISequencedDocumentMessage to be stored in the metadata blob in summary. */

package/src/summaryGenerator.ts

@@ -231,13 +231,14 @@ export class SummaryGenerator {
             const category = cancellationToken.cancelled || error?.errorType === DriverErrorType.offlineError ?
                 "generic" : "error";
 
+            const message = getFailMessage(errorCode);
             summarizeEvent.cancel({
                  ...properties,
                  reason: errorCode,
                  category,
                  retryAfterSeconds,
-            }, error);
-            resultsBuilder.fail(getFailMessage(errorCode), error, nackSummaryResult, retryAfterSeconds);
+            }, error ?? message); // disconnect & summaryAckTimeout do not have proper error.
+            resultsBuilder.fail(message, error, nackSummaryResult, retryAfterSeconds);
         };
 
         // Wait to generate and send summary