@fluidframework/container-runtime 2.0.0-dev.1.4.6.106135 → 2.0.0-dev.2.3.0.115467

package/src/opLifecycle/outbox.ts

@@ -0,0 +1,204 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/common-utils";
+import { IContainerContext } from "@fluidframework/container-definitions";
+import { GenericError } from "@fluidframework/container-utils";
+import { MessageType } from "@fluidframework/protocol-definitions";
+import { ICompressionRuntimeOptions } from "../containerRuntime";
+import { PendingStateManager } from "../pendingStateManager";
+import { BatchManager } from "./batchManager";
+import { BatchMessage, IBatch } from "./definitions";
+import { OpCompressor } from "./opCompressor";
+
+export interface IOutboxConfig {
+    readonly compressionOptions: ICompressionRuntimeOptions;
+    // The maximum size of a batch that we can send over the wire.
+    readonly maxBatchSizeInBytes: number;
+};
+
+export interface IOutboxParameters {
+    readonly shouldSend: () => boolean,
+    readonly pendingStateManager: PendingStateManager,
+    readonly containerContext: IContainerContext,
+    readonly config: IOutboxConfig,
+    readonly compressor: OpCompressor;
+}
+
+export class Outbox {
+    private readonly attachFlowBatch: BatchManager;
+    private readonly mainBatch: BatchManager;
+    private readonly defaultAttachFlowSoftLimitInBytes = 64 * 1024;
+
+    constructor(private readonly params: IOutboxParameters) {
+        const isCompressionEnabled = this.params.config.compressionOptions.minimumBatchSizeInBytes !== Number.POSITIVE_INFINITY;
+        // We need to allow infinite size batches if we enable compression
+        const hardLimit = isCompressionEnabled ? Infinity : this.params.config.maxBatchSizeInBytes;
+        const softLimit = isCompressionEnabled ? Infinity : this.defaultAttachFlowSoftLimitInBytes;
+
+        this.attachFlowBatch = new BatchManager({
+            hardLimit,
+            softLimit,
+        });
+        this.mainBatch = new BatchManager({
+            hardLimit
+        });
+    }
+
+    public get isEmpty(): boolean {
+        return this.attachFlowBatch.length === 0 && this.mainBatch.length === 0;
+    }
+
+    public submit(message: BatchMessage) {
+        if (!this.mainBatch.push(message)) {
+            throw new GenericError(
+                "BatchTooLarge",
+                /* error */ undefined,
+                {
+                    opSize: (message.contents?.length) ?? 0,
+                    count: this.mainBatch.length,
+                    limit: this.mainBatch.options.hardLimit,
+                });
+        }
+    }
+
+    public submitAttach(message: BatchMessage) {
+        if (!this.attachFlowBatch.push(message)) {
+            // BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
+            // when queue is not empty.
+            // Flush queue & retry. Failure on retry would mean - single message is bigger than hard limit
+            this.flushInternal(this.attachFlowBatch.popBatch());
+            if (!this.attachFlowBatch.push(message)) {
+                throw new GenericError(
+                    "BatchTooLarge",
+                    /* error */ undefined,
+                    {
+                        opSize: (message.contents?.length) ?? 0,
+                        count: this.attachFlowBatch.length,
+                        limit: this.attachFlowBatch.options.hardLimit,
+                    });
+            }
+        }
+
+        // If compression is enabled, we will always successfully receive
+        // attach ops and compress then send them at the next JS turn, regardless
+        // of the overall size of the accumulated ops in the batch.
+        // However, it is more efficient to flush these ops faster, preferably
+        // after they reach a size which would benefit from compression.
+        if (this.attachFlowBatch.contentSizeInBytes >= this.params.config.compressionOptions.minimumBatchSizeInBytes) {
+            this.flushInternal(this.attachFlowBatch.popBatch());
+        }
+    }
+
+    public flush() {
+        this.flushInternal(this.attachFlowBatch.popBatch());
+        this.flushInternal(this.mainBatch.popBatch());
+    }
+
+    private flushInternal(rawBatch: IBatch) {
+        const processedBatch = this.compressBatch(rawBatch);
+        const clientSequenceNumber = this.sendBatch(processedBatch);
+
+        this.persistBatch(clientSequenceNumber, rawBatch.content);
+    }
+
+    private compressBatch(batch: IBatch): IBatch {
+        if (batch.content.length === 0
+            || this.params.config.compressionOptions === undefined
+            || this.params.config.compressionOptions.minimumBatchSizeInBytes > batch.contentSizeInBytes) {
+            // Nothing to do if the batch is empty or if compression is disabled or if we don't need to compress
+            return batch;
+        }
+
+        const compressedBatch = this.params.compressor.compressBatch(batch);
+        if (compressedBatch.contentSizeInBytes > this.params.config.maxBatchSizeInBytes) {
+            throw new GenericError(
+                "BatchTooLarge",
+                    /* error */ undefined,
+                {
+                    opSize: batch.contentSizeInBytes,
+                    count: batch.content.length,
+                    limit: this.params.config.maxBatchSizeInBytes,
+                    compressed: true,
+                });
+        }
+
+        // If we don't reach the maximum supported size of a batch, it safe to be sent as is
+        return compressedBatch;
+    }
+
+    /**
+     * Sends the batch object to the container context to be sent over the wire.
+     *
+     * @param batch - batch to be sent
+     * @returns the client sequence number of the last batched op which was sent and
+     * -1 if there are no ops or the container cannot send ops.
+     */
+    private sendBatch(batch: IBatch): number {
+        let clientSequenceNumber: number = -1;
+        const length = batch.content.length;
+
+        // Did we disconnect in the middle of turn-based batch?
+        // If so, do nothing, as pending state manager will resubmit it correctly on reconnect.
+        if (length === 0 || !this.params.shouldSend()) {
+            return clientSequenceNumber;
+        }
+
+        if (this.params.containerContext.submitBatchFn === undefined) {
+            // Legacy path - supporting old loader versions. Can be removed only when LTS moves above
+            // version that has support for batches (submitBatchFn)
+            for (const message of batch.content) {
+                // Legacy path doesn't support compressed payloads and will submit uncompressed payload anyways
+                if (message.metadata?.compressed) {
+                    delete message.metadata.compressed;
+                }
+
+                clientSequenceNumber = this.params.containerContext.submitFn(
+                    MessageType.Operation,
+                    message.deserializedContent,
+                    true, // batch
+                    message.metadata);
+            }
+
+            this.params.containerContext.deltaManager.flush();
+        } else {
+            // returns clientSequenceNumber of last message in a batch
+            clientSequenceNumber = this.params.containerContext.submitBatchFn(
+                batch.content.map((message) => ({ contents: message.contents, metadata: message.metadata })));
+        }
+
+        // Convert from clientSequenceNumber of last message in the batch to clientSequenceNumber of first message.
+        clientSequenceNumber -= length - 1;
+        assert(clientSequenceNumber >= 0, 0x3d0 /* clientSequenceNumber can't be negative */);
+        return clientSequenceNumber;
+    }
+
+    private persistBatch(initialClientSequenceNumber: number, batch: BatchMessage[]) {
+        let clientSequenceNumber = initialClientSequenceNumber;
+        // Let the PendingStateManager know that a message was submitted.
+        // In future, need to shift toward keeping batch as a whole!
+        for (const message of batch) {
+            this.params.pendingStateManager.onSubmitMessage(
+                message.deserializedContent.type,
+                clientSequenceNumber,
+                message.referenceSequenceNumber,
+                message.deserializedContent.contents,
+                message.localOpMetadata,
+                message.metadata,
+            );
+
+            clientSequenceNumber++;
+        }
+
+        this.params.pendingStateManager.onFlush();
+    }
+
+    public checkpoint() {
+        return {
+            mainBatch: this.mainBatch.checkpoint(),
+            attachFlowBatch: this.attachFlowBatch.checkpoint(),
+        };
+    }
+}

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -0,0 +1,90 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
+import { ContainerMessageType, ContainerRuntimeMessage } from "../containerRuntime";
+import { OpDecompressor } from "./opDecompressor";
+import { OpSplitter } from "./opSplitter";
+
+export class RemoteMessageProcessor {
+    constructor(
+        private readonly opSplitter: OpSplitter,
+        private readonly opDecompressor: OpDecompressor,
+    ) { }
+
+    public get partialMessages(): ReadonlyMap<string, string[]> {
+        return this.opSplitter.chunks;
+    }
+
+    public clearPartialMessagesFor(clientId: string) {
+        this.opSplitter.clearPartialChunks(clientId);
+    }
+
+    public process(remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage {
+        let message = copy(remoteMessage);
+
+        message = this.opDecompressor.processMessage(message);
+        unpackRuntimeMessage(message);
+        message = this.opSplitter.processRemoteMessage(message);
+
+        return message;
+    }
+}
+
+const copy = (remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage => {
+    // Do shallow copy of message, as the processing flow will modify it.
+    // There might be multiple container instances receiving same message
+    // We do not need to make deep copy, as each layer will just replace message.content itself,
+    // but would not modify contents details
+    const message = { ...remoteMessage };
+
+    // back-compat: ADO #1385: eventually should become unconditional, but only for runtime messages!
+    // System message may have no contents, or in some cases (mostly for back-compat) they may have actual objects.
+    // Old ops may contain empty string (I assume noops).
+    if (typeof message.contents === "string" && message.contents !== "") {
+        message.contents = JSON.parse(message.contents);
+    }
+
+    return message;
+};
+
+/**
+ * For a given message, it moves the nested contents and type on level up.
+ *
+ */
+const unpack = (message: ISequencedDocumentMessage) => {
+    const innerContents = message.contents as ContainerRuntimeMessage;
+    message.type = innerContents.type;
+    message.contents = innerContents.contents;
+};
+
+/**
+ * Unpacks runtime messages.
+ *
+ * @remarks This API makes no promises regarding backward-compatibility. This is internal API.
+ * @param message - message (as it observed in storage / service)
+ * @returns unpacked runtime message
+ *
+ * @internal
+ */
+export function unpackRuntimeMessage(message: ISequencedDocumentMessage): boolean {
+    if (message.type !== MessageType.Operation) {
+        // Legacy format, but it's already "unpacked",
+        // i.e. message.type is actually ContainerMessageType.
+        // Or it's non-runtime message.
+        // Nothing to do in such case.
+        return false;
+    }
+
+    // legacy op format?
+    if (message.contents.address !== undefined && message.contents.type === undefined) {
+        message.type = ContainerMessageType.FluidDataStoreOp;
+    } else {
+        // new format
+        unpack(message);
+    }
+
+    return true;
+}

package/src/packageVersion.ts

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

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(