@fluidframework/container-runtime 2.0.0-dev.3.1.0.125672 → 2.0.0-dev.4.2.0.153917

package/src/{summarizer.ts → summary/summarizer.ts}

@@ -8,28 +8,22 @@ import { Deferred } from "@fluidframework/common-utils";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { ILoader, LoaderHeader } from "@fluidframework/container-definitions";
 import { UsageError } from "@fluidframework/container-utils";
-import { DriverErrorType, DriverHeader } from "@fluidframework/driver-definitions";
+import { DriverHeader } from "@fluidframework/driver-definitions";
 import { requestFluidObject } from "@fluidframework/runtime-utils";
 import {
 	ChildLogger,
 	IFluidErrorBase,
-	isFluidError,
 	LoggingError,
 	wrapErrorAndLog,
 } from "@fluidframework/telemetry-utils";
-import {
-	FluidObject,
-	IFluidHandleContext,
-	IFluidHandle,
-	IRequest,
-} from "@fluidframework/core-interfaces";
-import { ISummaryConfiguration } from "./containerRuntime";
+import { FluidObject, IFluidHandleContext, IRequest } from "@fluidframework/core-interfaces";
+import { ISummaryConfiguration } from "../containerRuntime";
 import { ICancellableSummarizerController } from "./runWhileConnectedCoordinator";
 import { summarizerClientType } from "./summarizerClientElection";
-import { IAckedSummary, SummaryCollection } from "./summaryCollection";
-import { SummarizerHandle } from "./summarizerHandle";
+import { SummaryCollection } from "./summaryCollection";
 import { RunningSummarizer } from "./runningSummarizer";
 import {
+	IConnectableRuntime,
 	ISummarizer,
 	ISummarizerInternalsProvider,
 	ISummarizerRuntime,
@@ -38,7 +32,6 @@ import {
 } from "./summarizerTypes";
 import { SummarizeHeuristicData } from "./summarizerHeuristics";
 import { SummarizeResultBuilder } from "./summaryGenerator";
-import { IConnectableRuntime } from ".";
 
 const summarizingError = "summarizingError";
 
@@ -68,9 +61,6 @@ export const createSummarizingWarning = (errorMessage: string, logged: boolean)
  * It is created only by summarizing container (i.e. one with clientType === "summarizer")
  */
 export class Summarizer extends EventEmitter implements ISummarizer {
-	public get IFluidLoadable() {
-		return this;
-	}
 	public get ISummarizer() {
 		return this;
 	}
@@ -80,15 +70,9 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 	private _disposed: boolean = false;
 	private starting: boolean = false;
 
-	private readonly innerHandle: IFluidHandle<this>;
-
-	public get handle(): IFluidHandle<this> {
-		return this.innerHandle;
-	}
 	private readonly stopDeferred = new Deferred<SummarizerStopReason>();
 
 	constructor(
-		url: string,
 		/** Reference to runtime that created this object.
 		 * i.e. runtime with clientType === "summarizer"
 		 */
@@ -106,7 +90,6 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 	) {
 		super();
 		this.logger = ChildLogger.create(this.runtime.logger, "Summarizer");
-		this.innerHandle = new SummarizerHandle(this, url, handleContext);
 	}
 
 	/**
@@ -133,10 +116,12 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 		};
 
 		const resolvedContainer = await loader.resolve(request);
-		const fluidObject = await requestFluidObject<FluidObject<ISummarizer>>(resolvedContainer, {
-			url: "_summarizer",
-		});
-		if (fluidObject.ISummarizer === undefined) {
+		const fluidObject: FluidObject<ISummarizer> | undefined = resolvedContainer.getEntryPoint
+			? await resolvedContainer.getEntryPoint?.()
+			: await requestFluidObject<FluidObject<ISummarizer>>(resolvedContainer, {
+					url: "_summarizer",
+			  });
+		if (fluidObject?.ISummarizer === undefined) {
 			throw new UsageError("Fluid object does not implement ISummarizer");
 		}
 		return fluidObject.ISummarizer;
@@ -272,19 +257,12 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 			this.summaryCollection.createWatcher(clientId),
 			this.configurationGetter(),
 			async (...args) => this.internalsProvider.submitSummary(...args), // submitSummaryCallback
+			async (...args) => this.internalsProvider.refreshLatestSummaryAck(...args), // refreshLatestSummaryCallback
 			new SummarizeHeuristicData(this.runtime.deltaManager.lastSequenceNumber, {
 				/** summary attempt baseline for heuristics */
 				refSequenceNumber: this.runtime.deltaManager.initialSequenceNumber,
 				summaryTime: Date.now(),
 			} as const),
-			(errorMessage: string) => {
-				if (!this._disposed) {
-					this.logger.sendErrorEvent(
-						{ eventName: "summarizingError" },
-						createSummarizingWarning(errorMessage, true),
-					);
-				}
-			},
 			this.summaryCollection,
 			runCoordinator /* cancellationToken */,
 			(reason) => runCoordinator.stop(reason) /* stopSummarizerCallback */,
@@ -293,12 +271,6 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 		this.runningSummarizer = runningSummarizer;
 		this.starting = false;
 
-		// Handle summary acks
-		// Note: no exceptions are thrown from handleSummaryAcks handler as it handles all exceptions
-		this.handleSummaryAcks().catch((error) => {
-			this.logger.sendErrorEvent({ eventName: "HandleSummaryAckFatalError" }, error);
-		});
-
 		return runningSummarizer;
 	}
 
@@ -389,69 +361,4 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 		}
 		return this.runningSummarizer.enqueueSummarize(...args);
 	};
-
-	private async handleSummaryAcks() {
-		let refSequenceNumber = this.runtime.deltaManager.initialSequenceNumber;
-		let ack: IAckedSummary | undefined;
-		while (this.runningSummarizer) {
-			const summaryLogger =
-				this.runningSummarizer.tryGetCorrelatedLogger(refSequenceNumber) ?? this.logger;
-			try {
-				// Initialize ack with undefined if exception happens inside of waitSummaryAck on second iteration,
-				// we record undefined, not previous handles.
-				ack = undefined;
-				ack = await this.summaryCollection.waitSummaryAck(refSequenceNumber);
-				refSequenceNumber = ack.summaryOp.referenceSequenceNumber;
-				const summaryOpHandle = ack.summaryOp.contents.handle;
-				const summaryAckHandle = ack.summaryAck.contents.handle;
-				// Make sure we block any summarizer from being executed/enqueued while
-				// executing the refreshLatestSummaryAck.
-				// https://dev.azure.com/fluidframework/internal/_workitems/edit/779
-				await this.runningSummarizer.lockedRefreshSummaryAckAction(async () =>
-					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
-							// latest version with which we will refresh the state. However in case of single commit
-							// summary, we might me missing a summary ack, so in that case we are still fine as the
-							// code in `submitSummary` function in container runtime, will refresh the latest state
-							// by calling `refreshLatestSummaryAckFromServer` and we will be fine.
-							if (
-								isFluidError(error) &&
-								error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError
-							) {
-								summaryLogger.sendTelemetryEvent(
-									{
-										eventName: "HandleSummaryAckErrorIgnored",
-										referenceSequenceNumber: refSequenceNumber,
-										proposalHandle: summaryOpHandle,
-										ackHandle: summaryAckHandle,
-									},
-									error,
-								);
-							} else {
-								throw error;
-							}
-						}),
-				);
-			} catch (error) {
-				summaryLogger.sendErrorEvent(
-					{
-						eventName: "HandleSummaryAckError",
-						referenceSequenceNumber: refSequenceNumber,
-						handle: ack?.summaryOp?.contents?.handle,
-						ackHandle: ack?.summaryAck?.contents?.handle,
-					},
-					error,
-				);
-			}
-			refSequenceNumber++;
-		}
-	}
 }

package/src/{summarizerHeuristics.ts → summary/summarizerHeuristics.ts}

@@ -5,7 +5,7 @@
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { Timer } from "@fluidframework/common-utils";
-import { ISummaryConfigurationHeuristics } from "./containerRuntime";
+import { ISummaryConfigurationHeuristics } from "../containerRuntime";
 import {
 	ISummarizeHeuristicData,
 	ISummarizeHeuristicRunner,
@@ -26,6 +26,10 @@ export class SummarizeHeuristicData implements ISummarizeHeuristicData {
 		return this._lastSuccessfulSummary;
 	}
 
+	public get opsSinceLastSummary(): number {
+		return this.numSystemOpsBefore + this.numNonSystemOpsBefore;
+	}
+
 	public numNonRuntimeOps: number = 0;
 	public totalOpsSize: number = 0;
 	public hasMissingOpData: boolean = false;
@@ -157,16 +161,21 @@ export class SummarizeHeuristicRunner implements ISummarizeHeuristicRunner {
 	}
 
 	public shouldRunLastSummary(): boolean {
-		const opsSinceLastAck = this.opsSinceLastAck;
+		const weightedOpsSinceLastAck = getWeightedNumberOfOps(
+			this.heuristicData.numRuntimeOps,
+			this.heuristicData.numNonRuntimeOps,
+			this.configuration.runtimeOpWeight,
+			this.configuration.nonRuntimeOpWeight,
+		);
 		const minOpsForLastSummaryAttempt = this.configuration.minOpsForLastSummaryAttempt;
 
 		this.logger.sendTelemetryEvent({
 			eventName: "ShouldRunLastSummary",
-			opsSinceLastAck,
+			weightedOpsSinceLastAck,
 			minOpsForLastSummaryAttempt,
 		});
 
-		return opsSinceLastAck >= minOpsForLastSummaryAttempt;
+		return weightedOpsSinceLastAck >= minOpsForLastSummaryAttempt;
 	}
 
 	public dispose() {

package/src/summary/summarizerNode/index.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	IFetchSnapshotResult,
+	ISummarizerNodeRootContract,
+	RefreshSummaryResult,
+} from "./summarizerNodeUtils";
+export { IRootSummarizerNode, createRootSummarizerNode } from "./summarizerNode";
+export { IRootSummarizerNodeWithGC, createRootSummarizerNodeWithGC } from "./summarizerNodeWithGc";