@fluidframework/container-runtime 0.58.2002 → 0.58.3000-61081

package/src/containerRuntime.ts

@@ -91,7 +91,6 @@ import {
 import {
     addBlobToSummary,
     addTreeToSummary,
-    convertToSummaryTree,
     createRootSummarizerNodeWithGC,
     IRootSummarizerNodeWithGC,
     RequestParser,
@@ -100,6 +99,7 @@ import {
     requestFluidObject,
     responseToException,
     seqFromTree,
+    calculateStats,
 } from "@fluidframework/runtime-utils";
 import { v4 as uuid } from "uuid";
 import { ContainerFluidHandleContext } from "./containerHandleContext";
@@ -152,6 +152,7 @@ import {
     isDataStoreAliasMessage,
 } from "./dataStore";
 import { BindBatchTracker } from "./batchTracker";
+import { OpTracker } from "./opTelemetry";
 
 export enum ContainerMessageType {
     // An op to be delivered to store
@@ -277,8 +278,8 @@ export interface ISummaryRuntimeOptions {
  * Options for container runtime.
  */
 export interface IContainerRuntimeOptions {
-    summaryOptions?: ISummaryRuntimeOptions;
-    gcOptions?: IGCRuntimeOptions;
+    readonly summaryOptions?: ISummaryRuntimeOptions;
+    readonly gcOptions?: IGCRuntimeOptions;
     /**
      * Affects the behavior while loading the runtime when the data verification check which
      * compares the DeltaManager sequence number (obtained from protocol in summary) to the
@@ -287,13 +288,20 @@ export interface IContainerRuntimeOptions {
      * 2. "log" will log an error event to telemetry, but still continue to load.
      * 3. "bypass" will skip the check entirely. This is not recommended.
      */
-    loadSequenceNumberVerification?: "close" | "log" | "bypass";
+    readonly loadSequenceNumberVerification?: "close" | "log" | "bypass";
     /**
      * Should the runtime use data store aliasing for creating root datastores.
      * In case of aliasing conflicts, the runtime will raise an exception which does
      * not effect the status of the container.
      */
-    useDataStoreAliasing?: boolean;
+    readonly useDataStoreAliasing?: boolean;
+    /**
+     * Sets the flush mode for the runtime. In Immediate flush mode the runtime will immediately
+     * send all operations to the driver layer, while in TurnBased the operations will be buffered
+     * and then sent them as a single batch at the end of the turn.
+     * By default, flush mode is TurnBased.
+     */
+    readonly flushMode?: FlushMode;
 }
 
 type IRuntimeMessageMetadata = undefined | {
@@ -347,6 +355,13 @@ const maxOpSizeInBytesKey = "Fluid.ContainerRuntime.MaxOpSizeInBytes";
 // to not reach the 1MB limits in socket.io and Kafka.
 const defaultMaxOpSizeInBytes = 768000;
 
+// By default, the size of the contents for the incoming ops is tracked.
+// However, in certain situations, this may incur a performance hit.
+// The feature-gate below can be used to disable this feature.
+const disableOpTrackingKey = "Fluid.ContainerRuntime.DisableOpTracking";
+
+const defaultFlushMode = FlushMode.TurnBased;
+
 export enum RuntimeMessage {
     FluidDataStoreOp = "component",
     Attach = "attach",
@@ -394,6 +409,7 @@ class ScheduleManagerCore {
     private currentBatchClientId: string | undefined;
     private localPaused = false;
     private timePaused = 0;
+    private batchCount = 0;
 
     constructor(
         private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
@@ -482,14 +498,30 @@ class ScheduleManagerCore {
         this.deltaManager.inbound.pause();
     }
 
-    private resumeQueue(startBatch: number, endBatch: number) {
+    private resumeQueue(startBatch: number, messageEndBatch: ISequencedDocumentMessage) {
+        const endBatch = messageEndBatch.sequenceNumber;
+        const duration = performance.now() - this.timePaused;
+
+        this.batchCount++;
+        if (this.batchCount % 1000 === 1) {
+            this.logger.sendTelemetryEvent({
+                eventName: "BatchStats",
+                sequenceNumber: endBatch,
+                length: endBatch - startBatch + 1,
+                msnDistance: endBatch - messageEndBatch.minimumSequenceNumber,
+                duration,
+                batchCount: this.batchCount,
+                interrupted: this.localPaused,
+            });
+        }
+
         // Return early if no change in value
         if (!this.localPaused) {
             return;
         }
 
         this.localPaused = false;
-        const duration = performance.now() - this.timePaused;
+
         // Random round number - we want to know when batch waiting paused op processing.
         if (duration > latencyThreshold) {
             this.logger.sendErrorEvent({
@@ -564,7 +596,7 @@ class ScheduleManagerCore {
         } else if (batchMetadata === false) {
             assert(this.pauseSequenceNumber !== undefined, 0x2a0 /* "batch presence was validated above" */);
             // Batch is complete, we can process it!
-            this.resumeQueue(this.pauseSequenceNumber, message.sequenceNumber);
+            this.resumeQueue(this.pauseSequenceNumber, message);
             this.pauseSequenceNumber = undefined;
             this.currentBatchClientId = undefined;
         } else {
@@ -710,6 +742,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             gcOptions = {},
             loadSequenceNumberVerification = "close",
             useDataStoreAliasing = false,
+            flushMode = defaultFlushMode,
         } = runtimeOptions;
 
         // We pack at data store level only. If isolated channels are disabled,
@@ -805,6 +838,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
                 gcOptions,
                 loadSequenceNumberVerification,
                 useDataStoreAliasing,
+                flushMode,
             },
             containerScope,
             logger,
@@ -909,7 +943,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     private readonly defaultMaxConsecutiveReconnects = 15;
 
     private _orderSequentiallyCalls: number = 0;
-    private _flushMode: FlushMode = FlushMode.TurnBased;
+    private _flushMode: FlushMode;
     private needsFlush = false;
     private flushTrigger = false;
 
@@ -983,6 +1017,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
 
     private readonly createContainerMetadata: ICreateContainerMetadata;
     private summaryCount: number | undefined;
+    private readonly opTracker: OpTracker;
 
     private constructor(
         private readonly context: IContainerContext,
@@ -1037,6 +1072,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         this.maxConsecutiveReconnects =
             this.mc.config.getNumber(maxConsecutiveReconnectsKey) ?? this.defaultMaxConsecutiveReconnects;
 
+        this._flushMode = runtimeOptions.flushMode;
         this.garbageCollector = GarbageCollector.create(
             this,
             this.runtimeOptions.gcOptions,
@@ -1277,6 +1313,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
 
         ReportOpPerfTelemetry(this.context.clientId, this.deltaManager, this.logger);
         BindBatchTracker(this, this.logger);
+        this.opTracker = new OpTracker(this.deltaManager, this.mc.config.getBoolean(disableOpTrackingKey) === true);
     }
 
     public dispose(error?: Error): void {
@@ -1446,13 +1483,12 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             const electedSummarizerContent = JSON.stringify(this.summarizerClientElection?.serialize());
             addBlobToSummary(summaryTree, electedSummarizerBlobName, electedSummarizerContent);
         }
-        const snapshot = this.blobManager.snapshot();
 
+        const summary = this.blobManager.summarize();
         // Some storage (like git) doesn't allow empty tree, so we can omit it.
         // and the blob manager can handle the tree not existing when loading
-        if (snapshot.entries.length !== 0) {
-            const blobsTree = convertToSummaryTree(snapshot, false);
-            addTreeToSummary(summaryTree, blobsTreeName, blobsTree);
+        if (Object.keys(summary.summary.tree).length > 0) {
+            addTreeToSummary(summaryTree, blobsTreeName, summary);
         }
 
         if (this.garbageCollector.writeDataAtRoot) {
@@ -1700,6 +1736,12 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             return;
         }
 
+        this.mc.logger.sendTelemetryEvent({
+            eventName: "FlushMode Updated",
+            old: this._flushMode,
+            new: mode,
+        });
+
         // Flush any pending batches if switching to immediate
         if (mode === FlushMode.Immediate) {
             this.flush();
@@ -1864,6 +1906,10 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             Array.isArray(pkg) ? pkg : [pkg], id, isRoot, props).realize();
         if (isRoot) {
             fluidDataStore.bindToContext();
+            this.logger.sendTelemetryEvent({
+                eventName: "Root datastore with props",
+                hasProps: props !== undefined,
+            });
         }
         return channelToDataStore(fluidDataStore, id, this, this.dataStores, this.mc.logger);
     }
@@ -2041,11 +2087,12 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             gcStats = await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC });
         }
 
-        const summarizeResult = await this.summarizerNode.summarize(fullTree, trackState);
-        assert(summarizeResult.summary.type === SummaryType.Tree,
+        const { stats, summary } = await this.summarizerNode.summarize(fullTree, trackState);
+
+        assert(summary.type === SummaryType.Tree,
             0x12f /* "Container Runtime's summarize should always return a tree" */);
 
-        return { ...summarizeResult, gcStats } as IRootSummaryTreeWithStats;
+        return { stats, summary, gcStats };
     }
 
     /**
@@ -2144,6 +2191,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             await this.deltaManager.inbound.pause();
 
             const summaryRefSeqNum = this.deltaManager.lastSequenceNumber;
+            const minimumSequenceNumber = this.deltaManager.minimumSequenceNumber;
             const message = `Summary @${summaryRefSeqNum}:${this.deltaManager.minimumSequenceNumber}`;
 
             // We should be here is we haven't processed be here. If we are of if the last message's sequence number
@@ -2188,7 +2236,12 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
 
             let continueResult = checkContinue();
             if (!continueResult.continue) {
-                return { stage: "base", referenceSequenceNumber: summaryRefSeqNum, error: continueResult.error };
+                return {
+                    stage: "base",
+                    referenceSequenceNumber: summaryRefSeqNum,
+                    minimumSequenceNumber,
+                    error: continueResult.error,
+                };
             }
 
             // increment summary count
@@ -2211,7 +2264,12 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
                     runGC: this.garbageCollector.shouldRunGC,
                 });
             } catch (error) {
-                return { stage: "base", referenceSequenceNumber: summaryRefSeqNum, error };
+                return {
+                    stage: "base",
+                    referenceSequenceNumber: summaryRefSeqNum,
+                    minimumSequenceNumber,
+                    error,
+                };
             }
             const { summary: summaryTree, stats: partialStats } = summarizeResult;
 
@@ -2226,15 +2284,23 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             assert(dataStoreTree.type === SummaryType.Tree, 0x1fc /* "summary is not a tree" */);
             const handleCount = Object.values(dataStoreTree.tree).filter(
                 (value) => value.type === SummaryType.Handle).length;
+            const gcSummaryTreeStats = summaryTree.tree[gcTreeKey]
+                ? calculateStats((summaryTree.tree[gcTreeKey] as ISummaryTree))
+                : undefined;
 
             const summaryStats: IGeneratedSummaryStats = {
                 dataStoreCount: this.dataStores.size,
                 summarizedDataStoreCount: this.dataStores.size - handleCount,
                 gcStateUpdatedDataStoreCount: summarizeResult.gcStats?.updatedDataStoreCount,
+                gcBlobNodeCount: gcSummaryTreeStats?.blobNodeCount,
+                gcTotalBlobsSize: gcSummaryTreeStats?.totalBlobSize,
+                opsSizesSinceLastSummary: this.opTracker.opsSizeAccumulator,
+                nonSystemOpsSinceLastSummary: this.opTracker.nonSystemOpCount,
                 ...partialStats,
             };
             const generateSummaryData = {
                 referenceSequenceNumber: summaryRefSeqNum,
+                minimumSequenceNumber,
                 summaryTree,
                 summaryStats,
                 generateDuration: trace.trace().duration,
@@ -2301,7 +2367,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             } as const;
 
             this.summarizerNode.completeSummary(handle);
-
+            this.opTracker.reset();
             return submitData;
         } finally {
             // Cleanup wip summary in case of failure

package/src/opTelemetry.ts

@@ -0,0 +1,71 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IDeltaManager } from "@fluidframework/container-definitions";
+import {
+    IDocumentMessage,
+    ISequencedDocumentMessage,
+    ISequencedDocumentSystemMessage,
+} from "@fluidframework/protocol-definitions";
+import { isSystemMessage } from "@fluidframework/protocol-base";
+
+export class OpTracker {
+    /**
+     * Used for storing the message content size when
+     * the message is pushed onto the inbound queue.
+     */
+    private readonly messageSize = new Map<number, number>();
+    private _nonSystemOpCount: number = 0;
+    public get nonSystemOpCount(): number {
+        return this._nonSystemOpCount;
+    }
+
+    private _opsSizeAccumulator: number = 0;
+    public get opsSizeAccumulator(): number {
+        return this._opsSizeAccumulator;
+    }
+
+    public constructor(
+        deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
+        disabled: boolean,
+    ) {
+        if (disabled) {
+            return;
+        }
+
+        // Record the message content size when we receive it.
+        // We should not log this value, as summarization can happen between the time the message
+        // is received and until it is processed (the 'op' event).
+        deltaManager.inbound.on("push", (message: ISequencedDocumentMessage) => {
+            // Some messages my already have string contents at this point,
+            // so stringifying them again will add inaccurate overhead.
+            const messageContent = typeof message.contents === "string" ?
+                message.contents :
+                JSON.stringify(message.contents);
+            const messageData = OpTracker.messageHasData(message) ? message.data : "";
+            this.messageSize[OpTracker.messageId(message)] = messageContent.length + messageData.length;
+        });
+
+        deltaManager.on("op", (message: ISequencedDocumentMessage) => {
+            this._nonSystemOpCount += isSystemMessage(message) ? 0 : 1;
+            const id = OpTracker.messageId(message);
+            this._opsSizeAccumulator += this.messageSize[id] ?? 0;
+            this.messageSize.delete(id);
+        });
+    }
+
+    private static messageId(message: ISequencedDocumentMessage): number {
+        return message.sequenceNumber;
+    }
+
+    private static messageHasData(message: ISequencedDocumentMessage): message is ISequencedDocumentSystemMessage {
+        return (message as ISequencedDocumentSystemMessage).data !== undefined;
+    }
+
+    public reset() {
+        this._nonSystemOpCount = 0;
+        this._opsSizeAccumulator = 0;
+    }
+}

package/src/orderedClientElection.ts

@@ -6,8 +6,10 @@
 import { IEvent, IEventProvider, ITelemetryLogger } from "@fluidframework/common-definitions";
 import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
+import { UsageError } from "@fluidframework/container-utils";
 import { IClient, IQuorumClients, ISequencedClient } from "@fluidframework/protocol-definitions";
 import { ChildLogger } from "@fluidframework/telemetry-utils";
+import { summarizerClientType } from "./summarizerClientElection";
 
 // helper types for recursive readonly.
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -206,16 +208,26 @@ export interface IOrderedClientElectionEvents extends IEvent {
 export interface ISerializedElection {
     /** Sequence number at the time of the latest election. */
     readonly electionSequenceNumber: number;
-    /** Most recently elected client id. */
+    /** Most recently elected client id. This is either:
+     * 1. the interactive elected parent client, in which case electedClientId === electedParentId,
+     *  and the SummaryManager on the elected client will spawn a summarizer client, or
+     * 2. the non-interactive summarizer client itself. */
     readonly electedClientId: string | undefined;
+    /** Most recently elected parent client id. This is always an interactive client. */
+    readonly electedParentId: string | undefined;
 }
 
 /** Contract for maintaining a deterministic client election based on eligibility. */
 export interface IOrderedClientElection extends IEventProvider<IOrderedClientElectionEvents> {
     /** Count of eligible clients in the collection. */
     readonly eligibleCount: number;
-    /** Currently elected client. */
+    /** Currently elected client. This is either:
+     * 1. the interactive elected parent client, in which case electedClientId === electedParentId,
+     *  and the SummaryManager on the elected client will spawn a summarizer client, or
+     * 2. the non-interactive summarizer client itself. */
     readonly electedClient: ITrackedClient | undefined;
+    /** Currently elected parent client. This is always an interactive client. */
+    readonly electedParent: ITrackedClient | undefined;
     /** Sequence number of most recent election. */
     readonly electionSequenceNumber: number;
     /** Marks the currently elected client as invalid, and elects the next eligible client. */
@@ -241,16 +253,50 @@ export class OrderedClientElection
     implements IOrderedClientElection {
     private _eligibleCount: number = 0;
     private _electedClient: ILinkedClient | undefined;
+    private _electedParent: ILinkedClient | undefined;
     private _electionSequenceNumber: number;
 
     public get eligibleCount() {
         return this._eligibleCount;
     }
+    public get electionSequenceNumber() {
+        return this._electionSequenceNumber;
+    }
+
+    /**
+     * OrderedClientCollection tracks electedClient and electedParent separately. This allows us to handle the case
+     * where a new interactive parent client has been elected, but the summarizer is still doing work, so
+     * a new summarizer should not yet be spawned. In this case, changing electedParent will cause SummaryManager
+     * to stop the current summarizer, but a new summarizer will not be spawned until the old summarizer client has
+     * left the quorum.
+     *
+     * Details:
+     *
+     * electedParent is the interactive client that has been elected to spawn a summarizer. It is typically the oldest
+     * eligible interactive client in the quorum. Only the electedParent is permitted to spawn a summarizer.
+     * Once elected, this client will remain the electedParent until it leaves the quorum or the summarizer that
+     * it spawned stops producing summaries, at which point a new electedParent will be chosen.
+     *
+     * electedClient is the non-interactive summarizer client if one exists. If not, then electedClient is equal to
+     * electedParent. If electedParent === electedClient, this is the signal for electedParent to spawn a new
+     * electedClient. Once a summarizer client becomes electedClient, a new summarizer will not be spawned until
+     * electedClient leaves the quorum.
+     *
+     * A typical sequence looks like this:
+     * i. Begin by electing A. electedParent === A, electedClient === A.
+     * ii. SummaryManager running on A spawns a summarizer client, A'. electedParent === A, electedClient === A'
+     * iii. A' stops producing summaries. A new parent client, B, is elected. electedParent === B, electedClient === A'
+     * iv. SummaryManager running on A detects the change to electedParent and tells the summarizer to stop, but A'
+     *      is in mid-summarization. No new summarizer is spawned, as electedParent !== electedClient.
+     * v. A' completes its summary, and the summarizer and backing client are torn down.
+     * vi. A' leaves the quorum, and B takes its place as electedClient. electedParent === B, electedClient === B
+     * vii. SummaryManager running on B spawns a summarizer client, B'. electedParent === B, electedClient === B'
+     */
     public get electedClient() {
         return this._electedClient;
     }
-    public get electionSequenceNumber() {
-        return this._electionSequenceNumber;
+    public get electedParent() {
+        return this._electedParent;
     }
 
     constructor(
@@ -262,11 +308,20 @@ export class OrderedClientElection
     ) {
         super();
         let initialClient: ILinkedClient | undefined;
+        let initialParent: ILinkedClient | undefined;
         for (const client of orderedClientCollection.getAllClients()) {
             this.addClient(client, 0);
             if (typeof initialState !== "number") {
                 if (client.clientId === initialState.electedClientId) {
                     initialClient = client;
+                    if (initialState.electedParentId === undefined &&
+                        client.client.details.type !== summarizerClientType) {
+                        // If there was no elected parent in the serialized data, use this one.
+                        initialParent = client;
+                    }
+                }
+                if (client.clientId === initialState.electedParentId) {
+                    initialParent = client;
                 }
             }
         }
@@ -288,7 +343,7 @@ export class OrderedClientElection
                 });
             } else if (initialClient !== undefined && !isEligibleFn(initialClient)) {
                 // Initially elected client is ineligible, so elect next eligible client.
-                initialClient = this.findFirstEligibleClient(initialClient);
+                initialClient = initialParent = this.findFirstEligibleParent(initialParent);
                 logger.sendErrorEvent({
                     eventName: "InitialElectedClientIneligible",
                     electionSequenceNumber: initialState.electionSequenceNumber,
@@ -296,31 +351,53 @@ export class OrderedClientElection
                     electedClientId: initialClient?.clientId,
                 });
             }
+            this._electedParent = initialParent;
             this._electedClient = initialClient;
             this._electionSequenceNumber = initialState.electionSequenceNumber;
         }
     }
 
-    /** Tries changing the elected client, raising an event if it is different. */
+    /** Tries changing the elected client, raising an event if it is different.
+     * Note that this function does no eligibility or suitability checks. If we get here, then
+     * we will set _electedClient, and we will set _electedParent if this is an interactive client.
+     */
     private tryElectingClient(client: ILinkedClient | undefined, sequenceNumber: number): void {
-        this._electionSequenceNumber = sequenceNumber;
-        if (this._electedClient === client) {
-            return;
-        }
+        let change = false;
+        const isSummarizerClient = client?.client.details.type === summarizerClientType;
         const prevClient = this._electedClient;
-        this._electedClient = client;
-        this.emit("election", client, sequenceNumber, prevClient);
+        if (this._electedClient !== client) {
+            // Changing the elected client. Record the sequence number and note that we have to fire an event.
+            this._electionSequenceNumber = sequenceNumber;
+            this._electedClient = client;
+            change = true;
+        }
+        if (this._electedParent !== client && !isSummarizerClient) {
+            // Changing the elected parent as well.
+            this._electedParent = client;
+            change = true;
+        }
+        if (change) {
+            this.emit("election", client, sequenceNumber, prevClient);
+        }
+    }
+
+    private tryElectingParent(client: ILinkedClient | undefined, sequenceNumber: number): void {
+        if (this._electedParent !== client) {
+            this._electedParent = client;
+            this.emit("election", this._electedClient, sequenceNumber, this._electedClient);
+        }
     }
 
     /**
-     * Helper function to find the first eligible client starting with the passed in client,
+     * Helper function to find the first eligible parent client starting with the passed in client,
      * or undefined if none are eligible.
      * @param client - client to start checking
      * @returns oldest eligible client starting with passed in client or undefined if none.
      */
-    private findFirstEligibleClient(client: ILinkedClient | undefined): ILinkedClient | undefined {
+    private findFirstEligibleParent(client: ILinkedClient | undefined): ILinkedClient | undefined {
         let candidateClient = client;
-        while (candidateClient !== undefined && !this.isEligibleFn(candidateClient)) {
+        while (candidateClient !== undefined &&
+            (!this.isEligibleFn(candidateClient) || candidateClient.client.details.type === summarizerClientType)) {
             candidateClient = candidateClient.youngerClient;
         }
         return candidateClient;
@@ -335,10 +412,16 @@ export class OrderedClientElection
     private addClient(client: ILinkedClient, sequenceNumber: number): void {
         if (this.isEligibleFn(client)) {
             this._eligibleCount++;
-            if (this._electedClient === undefined) {
-                // Automatically elect latest client
+            const newClientIsSummarizer = client.client.details.type === summarizerClientType;
+            const electedClientIsSummarizer = this._electedClient?.client.details.type === summarizerClientType;
+            // 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) {
+                // This is an odd case. If the _electedClient is set, the _electedParent should be as well.
+                this.tryElectingParent(client, sequenceNumber);
+            }
         }
     }
 
@@ -352,9 +435,33 @@ export class OrderedClientElection
         if (this.isEligibleFn(client)) {
             this._eligibleCount--;
             if (this._electedClient === client) {
-                // Automatically shift to next oldest client
-                const nextClient = this.findFirstEligibleClient(this._electedClient.youngerClient);
-                this.tryElectingClient(nextClient, sequenceNumber);
+                // Removing the _electedClient. There are 2 possible cases:
+                if (this._electedParent !== client) {
+                    // 1. The _electedClient is a summarizer that we've been allowing to finish its work.
+                    // Let the _electedParent become the _electedClient so that it can start its own summarizer.
+                    if (this._electedClient.client.details.type !== summarizerClientType) {
+                        throw new UsageError("Elected client should be a summarizer client 1");
+                    }
+                    this.tryElectingClient(this._electedParent, sequenceNumber);
+                }
+                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) {
+                // 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.
+                if (this._electedClient?.client.details.type !== summarizerClientType) {
+                    throw new UsageError("Elected client should be a summarizer client 2");
+                }
+                const nextParent = this.findFirstEligibleParent(this._electedParent?.youngerClient) ??
+                    this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
+                this.tryElectingParent(nextParent, sequenceNumber);
             }
         }
     }
@@ -363,24 +470,46 @@ export class OrderedClientElection
         return this.orderedClientCollection.getAllClients().filter(this.isEligibleFn);
     }
 
+    /** Advance election to the next-oldest client. This is called if the current parent is leaving the quorum,
+     * or if the current summarizer is not responsive and we want to stop it and spawn a new one.
+     */
     public incrementElectedClient(sequenceNumber: number): void {
-        const nextClient = this.findFirstEligibleClient(this._electedClient?.youngerClient);
-        this.tryElectingClient(nextClient, sequenceNumber);
+        const nextClient = this.findFirstEligibleParent(this._electedParent?.youngerClient) ??
+            this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
+        if (this._electedClient === undefined || this._electedClient === this._electedParent) {
+            this.tryElectingClient(nextClient, sequenceNumber);
+        }
+        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);
+        }
     }
 
+    /** (Re-)start election with the oldest client in the quorum. This is called if we need to summarize
+     * and no client has been elected.
+     */
     public resetElectedClient(sequenceNumber: number): void {
-        const firstClient = this.findFirstEligibleClient(this.orderedClientCollection.oldestClient);
-        this.tryElectingClient(firstClient, sequenceNumber);
+        const firstClient = this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
+        if (this._electedClient === undefined || this._electedClient === this._electedParent) {
+            this.tryElectingClient(firstClient, sequenceNumber);
+        }
+        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);
+        }
     }
 
     public peekNextElectedClient(): ITrackedClient | undefined {
-        return this.findFirstEligibleClient(this._electedClient?.youngerClient);
+        return this.findFirstEligibleParent(this._electedParent?.youngerClient);
     }
 
     public serialize(): ISerializedElection {
         return {
             electionSequenceNumber: this.electionSequenceNumber,
             electedClientId: this.electedClient?.clientId,
+            electedParentId: this.electedParent?.clientId,
         };
     }
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "0.58.2002";
+export const pkgVersion = "0.58.3000-61081";