@fluidframework/container-runtime 2.0.0-internal.6.0.0 → 2.0.0-internal.6.1.1

package/src/deltaManagerProxyBase.ts

@@ -0,0 +1,111 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { EventForwarder } from "@fluidframework/common-utils";
+import {
+	IDeltaManager,
+	IDeltaManagerEvents,
+	IDeltaQueue,
+	IDeltaSender,
+	ReadOnlyInfo,
+} from "@fluidframework/container-definitions";
+import {
+	IClientConfiguration,
+	IClientDetails,
+	IDocumentMessage,
+	ISequencedDocumentMessage,
+	ISignalMessage,
+} from "@fluidframework/protocol-definitions";
+
+/**
+ * Base class for creating proxy to the real delta manager. It implements all required methods on IDeltaManager and
+ * proxy implementations can override specific methods.
+ */
+export class DeltaManagerProxyBase
+	extends EventForwarder<IDeltaManagerEvents>
+	implements IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>
+{
+	public get IDeltaSender(): IDeltaSender {
+		return this;
+	}
+
+	public get inbound(): IDeltaQueue<ISequencedDocumentMessage> {
+		return this.deltaManager.inbound;
+	}
+
+	public get outbound(): IDeltaQueue<IDocumentMessage[]> {
+		return this.deltaManager.outbound;
+	}
+
+	public get inboundSignal(): IDeltaQueue<ISignalMessage> {
+		return this.deltaManager.inboundSignal;
+	}
+
+	public get minimumSequenceNumber(): number {
+		return this.deltaManager.minimumSequenceNumber;
+	}
+
+	public get lastSequenceNumber(): number {
+		return this.deltaManager.lastSequenceNumber;
+	}
+
+	public get lastMessage() {
+		return this.deltaManager.lastMessage;
+	}
+
+	public get lastKnownSeqNumber() {
+		return this.deltaManager.lastKnownSeqNumber;
+	}
+
+	public get initialSequenceNumber(): number {
+		return this.deltaManager.initialSequenceNumber;
+	}
+
+	public get hasCheckpointSequenceNumber() {
+		return this.deltaManager.hasCheckpointSequenceNumber;
+	}
+
+	public get clientDetails(): IClientDetails {
+		return this.deltaManager.clientDetails;
+	}
+
+	public get version(): string {
+		return this.deltaManager.version;
+	}
+
+	public get maxMessageSize(): number {
+		return this.deltaManager.maxMessageSize;
+	}
+
+	public get serviceConfiguration(): IClientConfiguration | undefined {
+		return this.deltaManager.serviceConfiguration;
+	}
+
+	public get active(): boolean {
+		return this.deltaManager.active;
+	}
+
+	public get readOnlyInfo(): ReadOnlyInfo {
+		return this.deltaManager.readOnlyInfo;
+	}
+
+	constructor(
+		protected readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
+	) {
+		super(deltaManager);
+	}
+
+	public dispose(): void {
+		super.dispose();
+	}
+
+	public submitSignal(content: any): void {
+		return this.deltaManager.submitSignal(content);
+	}
+
+	public flush(): void {
+		return this.deltaManager.flush();
+	}
+}

package/src/deltaManagerSummarizerProxy.ts

@@ -4,8 +4,9 @@
  */
 
 import { IDeltaManager, ReadOnlyInfo } from "@fluidframework/container-definitions";
-import { DeltaManagerProxyBase } from "@fluidframework/container-utils";
 import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+
+import { DeltaManagerProxyBase } from "./deltaManagerProxyBase";
 import { summarizerClientType } from "./summary";
 
 /**

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-internal.6.0.0";
+export const pkgVersion = "2.0.0-internal.6.1.1";

package/src/summary/runningSummarizer.ts

@@ -44,8 +44,6 @@ import {
 
 const maxSummarizeAckWaitTime = 10 * 60 * 1000; // 10 minutes
 
-const defaultNumberSummarizationAttempts = 2; // only up to 2 attempts
-
 /**
  * An instance of RunningSummarizer manages the heuristics for summarizing.
  * Until disposed, the instance of RunningSummarizer can assume that it is
@@ -573,31 +571,15 @@ export class RunningSummarizer implements IDisposable {
 				this.beforeSummaryAction();
 			},
 			async () => {
-				const attempts: (ISummarizeOptions & { delaySeconds?: number })[] = [
+				const attempts: ISummarizeOptions[] = [
 					{ refreshLatestAck: false, fullTree: false },
 					{ refreshLatestAck: true, fullTree: false },
-					{ refreshLatestAck: true, fullTree: false, delaySeconds: 2 * 60 },
-					{ refreshLatestAck: true, fullTree: true, delaySeconds: 10 * 60 },
 				];
 				let overrideDelaySeconds: number | undefined;
 				let summaryAttempts = 0;
 				let summaryAttemptsPerPhase = 0;
-				// Reducing the default number of attempts to defaultNumberofSummarizationAttempts.
-				let totalAttempts =
-					this.mc.config.getNumber("Fluid.Summarizer.Attempts") ??
-					defaultNumberSummarizationAttempts;
-
-				if (totalAttempts > attempts.length) {
-					this.mc.logger.sendTelemetryEvent({
-						eventName: "InvalidSummarizerAttempts",
-						attempts: totalAttempts,
-					});
-					totalAttempts = defaultNumberSummarizationAttempts;
-				} else if (totalAttempts < 1) {
-					throw new UsageError("Invalid number of attempts.");
-				}
-
-				for (let summaryAttemptPhase = 0; summaryAttemptPhase < totalAttempts; ) {
+				let summaryAttemptPhase = 0;
+				while (summaryAttemptPhase < attempts.length) {
 					if (this.cancellationToken.cancelled) {
 						return;
 					}
@@ -609,22 +591,20 @@ export class RunningSummarizer implements IDisposable {
 
 					summaryAttemptsPerPhase++;
 
-					const { delaySeconds: regularDelaySeconds = 0, ...options } =
-						attempts[summaryAttemptPhase];
-
+					const summarizeOptions = attempts[summaryAttemptPhase];
 					const summarizeProps: ISummarizeTelemetryProperties = {
 						reason,
 						summaryAttempts,
 						summaryAttemptsPerPhase,
 						summaryAttemptPhase: summaryAttemptPhase + 1, // make everything 1-based
-						...options,
+						...summarizeOptions,
 					};
 
 					// Note: no need to account for cancellationToken.waitCancelled here, as
 					// this is accounted SummaryGenerator.summarizeCore that controls receivedSummaryAckOrNack.
 					const resultSummarize = this.generator.summarize(
 						summarizeProps,
-						options,
+						summarizeOptions,
 						cancellationToken,
 					);
 					const result = await resultSummarize.receivedSummaryAckOrNack;
@@ -635,15 +615,13 @@ export class RunningSummarizer implements IDisposable {
 
 					// Check for retryDelay that can come from summaryNack or upload summary flow.
 					// Retry the same step only once per retryAfter response.
-					overrideDelaySeconds = result.retryAfterSeconds;
-					if (overrideDelaySeconds === undefined || summaryAttemptsPerPhase > 1) {
+					const delaySeconds = result.retryAfterSeconds;
+					if (delaySeconds === undefined || summaryAttemptsPerPhase > 1) {
 						summaryAttemptPhase++;
 						summaryAttemptsPerPhase = 0;
 					}
 
-					const delaySeconds = overrideDelaySeconds ?? regularDelaySeconds;
-
-					if (delaySeconds > 0) {
+					if (delaySeconds !== undefined) {
 						this.mc.logger.sendPerformanceEvent({
 							eventName: "SummarizeAttemptDelay",
 							duration: delaySeconds,

package/src/summary/summaryGenerator.ts

@@ -242,7 +242,6 @@ export class SummaryGenerator {
 		const { refreshLatestAck, fullTree } = options;
 		const logger = createChildLogger({
 			logger: this.logger,
-			namespace: undefined,
 			properties: { all: summarizeProps },
 		});