@fluidframework/container-runtime 0.48.5 → 0.49.1

package/src/containerRuntime.ts

@@ -1571,15 +1571,6 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         this.context.raiseContainerWarning(warning);
     };
 
-    /**
-     * @deprecated - // back-compat: marked deprecated in 0.35
-     * Returns true of document is dirty, i.e. there are some pending local changes that
-     * either were not sent out to delta stream or were not yet acknowledged.
-     */
-    public isDocumentDirty(): boolean {
-        return this.dirtyContainer;
-    }
-
     /**
      * Returns true of container is dirty, i.e. there are some pending local changes that
      * either were not sent out to delta stream or were not yet acknowledged.
@@ -1998,9 +1989,6 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
 
         this.dirtyContainer = dirty;
         if (this.emitDirtyDocumentEvent) {
-            // back-compat: dirtyDocument & savedDocument deprecated in 0.35.
-            this.emit(dirty ? "dirtyDocument" : "savedDocument");
-
             this.emit(dirty ? "dirty" : "saved");
             // back-compat: Loader API added in 0.35 only
             if (this.context.updateDirtyContainerState !== undefined) {
@@ -2194,11 +2182,13 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     public async refreshLatestSummaryAck(
         proposalHandle: string | undefined,
         ackHandle: string,
+        summaryRefSeq: number,
         summaryLogger: ITelemetryLogger,
     ) {
         const readAndParseBlob = async <T>(id: string) => readAndParse<T>(this.storage, id);
         const result = await this.summarizerNode.refreshLatestSummary(
             proposalHandle,
+            summaryRefSeq,
             async () => this.fetchSnapshotFromStorage(ackHandle, summaryLogger, {
                 eventName: "RefreshLatestSummaryGetSnapshot",
                 fetchLatest: false,
@@ -2238,6 +2228,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
 
         const result = await this.summarizerNode.refreshLatestSummary(
             undefined,
+            snapshotRefSeq,
             async () => snapshot,
             readAndParseBlob,
             summaryLogger,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "0.48.5";
+export const pkgVersion = "0.49.1";

package/src/runningSummarizer.ts

@@ -346,6 +346,8 @@ export class RunningSummarizer implements IDisposable {
             let totalAttempts = 0;
             let attemptPerPhase = 0;
 
+            let lastResult: { message: string; error: any; } | undefined;
+
             for (let attemptPhase = 0; attemptPhase < attempts.length;) {
                 if (this.cancellationToken.cancelled) {
                     return;
@@ -378,7 +380,6 @@ export class RunningSummarizer implements IDisposable {
                 const result = await resultSummarize.receivedSummaryAckOrNack;
 
                 if (result.success) {
-                    assert(result.data.summaryAckNackOp.type === MessageType.SummaryAck, 0x25c /* "not nack" */);
                     return;
                 }
                 // Check for retryDelay that can come from summaryNack or upload summary flow.
@@ -388,9 +389,16 @@ export class RunningSummarizer implements IDisposable {
                     attemptPhase++;
                     attemptPerPhase = 0;
                 }
+                lastResult = result;
             }
-            // If all attempts failed, close the summarizer container
-            this.logger.sendErrorEvent({ eventName: "FailToSummarize", summarizeReason });
+
+            // If all attempts failed, log error (with last attempt info) and close the summarizer container
+            this.logger.sendErrorEvent({
+                eventName: "FailToSummarize",
+                summarizeReason,
+                message: lastResult?.message,
+            }, lastResult?.error);
+
             this.stopSummarizerCallback("failToSummarize");
         }).catch((error) => {
             this.logger.sendErrorEvent({ eventName: "UnexpectedSummarizeError" }, error);

package/src/summarizer.ts

@@ -277,6 +277,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
                 await this.internalsProvider.refreshLatestSummaryAck(
                     ack.summaryOp.contents.handle,
                     ack.summaryAck.contents.handle,
+                    refSequenceNumber,
                     summaryLogger,
                 );
             } catch (error) {

package/src/summarizerTypes.ts

@@ -57,6 +57,7 @@ export interface ISummarizerInternalsProvider {
     refreshLatestSummaryAck(
         proposalHandle: string,
         ackHandle: string,
+        summaryRefSeq: number,
         summaryLogger: ITelemetryLogger,
     ): Promise<void>;
 }
@@ -196,17 +197,22 @@ export interface IBroadcastSummaryResult {
     readonly broadcastDuration: number;
 }
 
-export interface IAckNackSummaryResult {
-    readonly summaryAckNackOp: ISummaryAckMessage | ISummaryNackMessage;
+export interface IAckSummaryResult {
+    readonly summaryAckOp: ISummaryAckMessage;
     readonly ackNackDuration: number;
 }
 
-export type SummarizeResultPart<T> = {
+export interface INackSummaryResult {
+    readonly summaryNackOp: ISummaryNackMessage;
+    readonly ackNackDuration: number;
+}
+
+export type SummarizeResultPart<TSuccess, TFailure = undefined> = {
     success: true;
-    data: T;
+    data: TSuccess;
 } | {
     success: false;
-    data: T | undefined;
+    data: TFailure | undefined;
     message: string;
     error: any;
     retryAfterSeconds?: number;
@@ -218,7 +224,7 @@ export interface ISummarizeResults {
     /** Resolves when we observe our summarize op broadcast. */
     readonly summaryOpBroadcasted: Promise<SummarizeResultPart<IBroadcastSummaryResult>>;
     /** Resolves when we receive a summaryAck or summaryNack. */
-    readonly receivedSummaryAckOrNack: Promise<SummarizeResultPart<IAckNackSummaryResult>>;
+    readonly receivedSummaryAckOrNack: Promise<SummarizeResultPart<IAckSummaryResult, INackSummaryResult>>;
 }
 
 export type OnDemandSummarizeResult = (ISummarizeResults & {

package/src/summaryCollection.ts

@@ -226,6 +226,14 @@ export class SummaryCollection extends TypedEventEmitter<ISummaryCollectionOpEve
             (this.lastAck?.summaryAck.sequenceNumber ?? this.deltaManager.initialSequenceNumber);
     }
 
+    public addOpListener(listener: () => void) {
+        this.deltaManager.on("op", listener);
+    }
+
+    public removeOpListener(listener: () => void) {
+        this.deltaManager.off("op", listener);
+    }
+
     public constructor(
         private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
         private readonly logger: ITelemetryLogger,

package/src/summaryGenerator.ts

@@ -4,12 +4,19 @@
  */
 
 import { ITelemetryLogger, ITelemetryProperties } from "@fluidframework/common-definitions";
-import { assert, Deferred, IPromiseTimer, IPromiseTimerResult, Timer } from "@fluidframework/common-utils";
+import {
+    assert,
+    Deferred,
+    IPromiseTimer,
+    IPromiseTimerResult,
+    Timer,
+} from "@fluidframework/common-utils";
 import { MessageType } from "@fluidframework/protocol-definitions";
 import { PerformanceEvent, LoggingError, ChildLogger } from "@fluidframework/telemetry-utils";
 import { getRetryDelaySecondsFromError } from "@fluidframework/driver-utils";
 import {
-    IAckNackSummaryResult,
+    IAckSummaryResult,
+    INackSummaryResult,
     ISummarizeOptions,
     IBroadcastSummaryResult,
     ISummarizeResults,
@@ -118,9 +125,10 @@ const summarizeErrors = {
 export class SummarizeResultBuilder {
     public readonly summarySubmitted = new Deferred<SummarizeResultPart<SubmitSummaryResult>>();
     public readonly summaryOpBroadcasted = new Deferred<SummarizeResultPart<IBroadcastSummaryResult>>();
-    public readonly receivedSummaryAckOrNack = new Deferred<SummarizeResultPart<IAckNackSummaryResult>>();
+    public readonly receivedSummaryAckOrNack =
+        new Deferred<SummarizeResultPart<IAckSummaryResult, INackSummaryResult>>();
 
-    public fail(message: string, error: any, nackSummaryResult?: IAckNackSummaryResult, retryAfterSeconds?: number) {
+    public fail(message: string, error: any, nackSummaryResult?: INackSummaryResult, retryAfterSeconds?: number) {
         assert(!this.receivedSummaryAckOrNack.isCompleted,
             0x25e /* "no reason to call fail if all promises have been completed" */);
 
@@ -203,7 +211,7 @@ export class SummaryGenerator {
             errorCode: keyof typeof summarizeErrors,
             error?: any,
             properties?: ITelemetryProperties,
-            nackSummaryResult?: IAckNackSummaryResult,
+            nackSummaryResult?: INackSummaryResult,
         ) => {
             this.raiseSummarizingError(summarizeErrors[errorCode]);
             // UploadSummary may fail with 429 and retryAfter - respect that
@@ -327,16 +335,15 @@ export class SummaryGenerator {
                 this.heuristicData.markLastAttemptAsSuccessful();
                 summarizeEvent.end({ ...telemetryProps, handle: ackNackOp.contents.handle, message: "summaryAck" });
                 resultsBuilder.receivedSummaryAckOrNack.resolve({ success: true, data: {
-                    summaryAckNackOp: ackNackOp,
+                    summaryAckOp: ackNackOp,
                     ackNackDuration,
                 }});
             } else {
                 // Check for retryDelay in summaryNack response.
                 // back-compat: cast needed until dep on protocol-definitions version bump
-                const summaryNack = ackNackOp.type === MessageType.SummaryNack
-                    ? ackNackOp.contents as { message?: string; retryAfter?: number; }
-                    : undefined;
-                const message = (ackNackOp.contents as { message?: string }).message ?? ackNackOp.contents.errorMessage;
+                assert(ackNackOp.type === MessageType.SummaryNack, 0x274 /* "type check" */);
+                const summaryNack = ackNackOp.contents as { message?: string; retryAfter?: number; };
+                const message = summaryNack.message ?? ackNackOp.contents.errorMessage;
                 const retryAfterSeconds = summaryNack?.retryAfter;
 
                 const error = new LoggingError(`summaryNack: ${message}`, { retryAfterSeconds });
@@ -348,7 +355,7 @@ export class SummaryGenerator {
                     "summaryNack",
                     error,
                     { ...telemetryProps, nackRetryAfter: retryAfterSeconds },
-                    { summaryAckNackOp: ackNackOp, ackNackDuration },
+                    { summaryNackOp: ackNackOp, ackNackDuration },
                 );
             }
         } finally {

package/src/summaryManager.ts

@@ -4,7 +4,7 @@
  */
 
 import { IDisposable, IEvent, IEventProvider, ITelemetryLogger } from "@fluidframework/common-definitions";
-import { delay, TypedEventEmitter, assert } from "@fluidframework/common-utils";
+import { TypedEventEmitter, assert } from "@fluidframework/common-utils";
 import { ChildLogger, PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { IFluidRouter, IRequest } from "@fluidframework/core-interfaces";
 import { IDeltaManager, LoaderHeader } from "@fluidframework/container-definitions";
@@ -90,7 +90,8 @@ export class SummaryManager extends TypedEventEmitter<ISummaryManagerEvents> imp
     constructor(
         private readonly clientElection: ISummarizerClientElection,
         private readonly connectedState: IConnectedState,
-        private readonly summaryCollection: Pick<SummaryCollection, "opsSinceLastAck">,
+        private readonly summaryCollection:
+            Pick<SummaryCollection, "opsSinceLastAck" | "addOpListener" | "removeOpListener">,
         parentLogger: ITelemetryLogger,
         /** Creates summarizer by asking interactive container to spawn summarizing container and
          * get back its Summarizer instance. */
@@ -265,15 +266,9 @@ export class SummaryManager extends TypedEventEmitter<ISummaryManagerEvents> imp
             0x265 /* "Expected: Starting or Running" */);
         this.state = SummaryManagerState.Stopping;
 
-        if (this.summarizer !== undefined) {
-            // Stopping the running summarizer client should trigger a change
-            // in states when the running summarizer closes
-            this.summarizer.stop(reason);
-        } else {
-            // Should not be possible to hit this case
-            this.logger.sendErrorEvent({ eventName: "StopCalledWithoutRunningSummarizer", reason });
-            this.state = SummaryManagerState.Off;
-        }
+        // Stopping the running summarizer client should trigger a change
+        // in states when the running summarizer closes
+        this.summarizer?.stop(reason);
     }
 
     /**
@@ -284,7 +279,7 @@ export class SummaryManager extends TypedEventEmitter<ISummaryManagerEvents> imp
     private async delayBeforeCreatingSummarizer(): Promise<boolean> {
         // throttle creation of new summarizer containers to prevent spamming the server with websocket connections
         let delayMs = this.startThrottler.getDelay();
-        if (delayMs > 0 && delayMs >= this.startThrottler.maxDelayMs) {
+        if (delayMs > 0 && delayMs > this.startThrottler.maxDelayMs) {
             this.emit(
                 "summarizerWarning",
                 createSummarizingWarning("summaryManagerCreateSummarizerMaxThrottleDelay", false),
@@ -317,7 +312,24 @@ export class SummaryManager extends TypedEventEmitter<ISummaryManagerEvents> imp
         }
 
         if (delayMs > 0) {
-            await delay(delayMs);
+            let timer;
+            let resolveOpPromiseFn;
+            // Create a listener that will break the delay if we've exceeded the initial delay ops count.
+            const opsListenerFn = () => {
+                if (this.summaryCollection.opsSinceLastAck >= this.opsToBypassInitialDelay) {
+                    clearTimeout(timer);
+                    resolveOpPromiseFn();
+                }
+            };
+            // Create a Promise that will resolve when the delay expires.
+            const delayPromise = new Promise<void>((resolve) => {
+                timer = setTimeout(() => resolve(), delayMs);
+            });
+            // Create a Promise that will resolve if the ops count passes the threshold.
+            const opPromise = new Promise<void>((resolve) => { resolveOpPromiseFn = resolve; });
+            this.summaryCollection.addOpListener(opsListenerFn);
+            await Promise.race([ delayPromise, opPromise ]);
+            this.summaryCollection.removeOpListener(opsListenerFn);
         }
         return startWithInitialDelay;
     }