@fluidframework/container-runtime 0.56.0 → 0.57.0-51086

package/src/runningSummarizer.ts

@@ -93,6 +93,7 @@ export class RunningSummarizer implements IDisposable {
         readonly resultsBuilder: SummarizeResultBuilder;
     } | undefined;
     private summarizeCount = 0;
+    private totalSuccessfulAttempts = 0;
 
     private constructor(
         baseLogger: ITelemetryLogger,
@@ -107,7 +108,14 @@ export class RunningSummarizer implements IDisposable {
         { disableHeuristics = false }: Readonly<Partial<ISummarizerOptions>> = {},
     ) {
         this.logger = ChildLogger.create(
-            baseLogger, "Running", { all: { summaryGenTag: () => this.summarizeCount } });
+            baseLogger, "Running",
+            {
+                all: {
+                    summarizeCount: () => this.summarizeCount,
+                    summarizerSuccessfulAttempts: () => this.totalSuccessfulAttempts,
+                },
+            },
+        );
 
         if (!disableHeuristics) {
             this.heuristicRunner = new SummarizeHeuristicRunner(
@@ -124,7 +132,7 @@ export class RunningSummarizer implements IDisposable {
             maxAckWaitTime,
             () => {
                 this.raiseSummarizingError("summaryAckWaitTimeout");
-                // Note: summaryGenTag (from ChildLogger definition) may be 0,
+                // Note: summarizeCount (from ChildLogger definition) may be 0,
                 // since this code path is hit when RunningSummarizer first starts up,
                 // before this instance has kicked off a new summarize run.
                 this.logger.sendErrorEvent({
@@ -152,6 +160,7 @@ export class RunningSummarizer implements IDisposable {
             this.heuristicData,
             this.submitSummaryCallback,
             this.raiseSummarizingError,
+            () => { this.totalSuccessfulAttempts++; },
             this.summaryWatcher,
             this.logger,
         );
@@ -183,8 +192,7 @@ export class RunningSummarizer implements IDisposable {
         switch (op.type) {
             case MessageType.ClientLeave:
             case MessageType.ClientJoin:
-            case MessageType.Propose:
-            case MessageType.Reject: {
+            case MessageType.Propose: {
                 // Synchronously handle quorum ops like regular ops
                 this.handleOp(undefined, op);
                 return;
@@ -338,27 +346,27 @@ export class RunningSummarizer implements IDisposable {
                 { refreshLatestAck: true, fullTree: true, delaySeconds: 10 * 60 },
             ];
             let overrideDelaySeconds: number | undefined;
-            let totalAttempts = 0;
-            let attemptPerPhase = 0;
+            let summaryAttempts = 0;
+            let summaryAttemptsPerPhase = 0;
 
             let lastResult: { message: string; error: any; } | undefined;
 
-            for (let attemptPhase = 0; attemptPhase < attempts.length;) {
+            for (let summaryAttemptPhase = 0; summaryAttemptPhase < attempts.length;) {
                 if (this.cancellationToken.cancelled) {
                     return;
                 }
 
-                totalAttempts++;
-                attemptPerPhase++;
+                summaryAttempts++;
+                summaryAttemptsPerPhase++;
 
-                const { delaySeconds: regularDelaySeconds = 0, ...options } = attempts[attemptPhase];
+                const { delaySeconds: regularDelaySeconds = 0, ...options } = attempts[summaryAttemptPhase];
                 const delaySeconds = overrideDelaySeconds ?? regularDelaySeconds;
 
                 const summarizeProps: ITelemetryProperties = {
                     summarizeReason,
-                    summarizeTotalAttempts: totalAttempts,
-                    summarizeAttemptsPerPhase: attemptPerPhase,
-                    summarizeAttemptPhase: attemptPhase + 1, // make everything 1-based
+                    summaryAttempts,
+                    summaryAttemptsPerPhase,
+                    summaryAttemptPhase: summaryAttemptPhase + 1, // make everything 1-based
                     ...options,
                 };
 
@@ -377,14 +385,15 @@ export class RunningSummarizer implements IDisposable {
                 const result = await resultSummarize.receivedSummaryAckOrNack;
 
                 if (result.success) {
+                    this.totalSuccessfulAttempts++;
                     return;
                 }
                 // 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 || attemptPerPhase > 1) {
-                    attemptPhase++;
-                    attemptPerPhase = 0;
+                if (overrideDelaySeconds === undefined || summaryAttemptsPerPhase > 1) {
+                    summaryAttemptPhase++;
+                    summaryAttemptsPerPhase = 0;
                 }
                 lastResult = result;
             }

package/src/summarizerTypes.ts

@@ -20,14 +20,6 @@ import {
 import { ISummaryStats } from "@fluidframework/runtime-definitions";
 import { ISummaryAckMessage, ISummaryNackMessage, ISummaryOpMessage } from "./summaryCollection";
 
-declare module "@fluidframework/core-interfaces" {
-    export interface IFluidObject {
-        /** @deprecated - use `FluidObject<ISummarizer>` instead */
-        readonly ISummarizer?: ISummarizer;
-
-     }
-}
-
 /**
  * @deprecated - This will be removed in a later release.
  */
@@ -144,8 +136,12 @@ export interface IEnqueueSummarizeOptions extends IOnDemandSummarizeOptions {
  * only relevant at the root of the tree.
  */
 export interface IGeneratedSummaryStats extends ISummaryStats {
+    /** The total number of data stores in the container. */
     readonly dataStoreCount: number;
+    /** The number of data stores that were summarized in this summary. */
     readonly summarizedDataStoreCount: number;
+    /** The number of data stores whose GC reference state was updated in this summary. */
+    readonly gcStateUpdatedDataStoreCount?: number;
 }
 
 /** Base results for all submitSummary attempts. */
@@ -166,6 +162,8 @@ export interface IGenerateSummaryTreeResult extends Omit<IBaseSummarizeResult, "
     readonly summaryStats: IGeneratedSummaryStats;
     /** Time it took to generate the summary tree and stats. */
     readonly generateDuration: number;
+    /** True if the full tree regeneration with no handle reuse optimizations was forced. */
+    readonly forcedFullTree: boolean;
 }
 
 /** Results of submitSummary after uploading the tree to storage. */

package/src/summaryGenerator.ts

@@ -153,6 +153,7 @@ export class SummaryGenerator {
         private readonly heuristicData: ISummarizeHeuristicData,
         private readonly submitSummaryCallback: (options: ISubmitSummaryOptions) => Promise<SubmitSummaryResult>,
         private readonly raiseSummarizingError: (errorCode: string) => void,
+        private readonly successfulSummaryCallback: () => void,
         private readonly summaryWatcher: Pick<IClientSummaryWatcher, "watchSummary">,
         private readonly logger: ITelemetryLogger,
     ) {
@@ -193,13 +194,21 @@ export class SummaryGenerator {
     ): Promise<void> {
         const { refreshLatestAck, fullTree } = options;
         const logger = ChildLogger.create(this.logger, undefined, { all: summarizeProps });
+
+        const timeSinceLastAttempt = Date.now() - this.heuristicData.lastAttempt.summaryTime;
+        const timeSinceLastSummary = Date.now() - this.heuristicData.lastSuccessfulSummary.summaryTime;
+        let summarizeTelemetryProps: Record<string, string | number | boolean | undefined> = {
+            fullTree,
+            timeSinceLastAttempt,
+            timeSinceLastSummary,
+        }
+
         const summarizeEvent = PerformanceEvent.start(logger, {
             eventName: "Summarize",
             refreshLatestAck,
-            fullTree,
-            timeSinceLastAttempt: Date.now() - this.heuristicData.lastAttempt.summaryTime,
-            timeSinceLastSummary: Date.now() - this.heuristicData.lastSuccessfulSummary.summaryTime,
+            ...summarizeTelemetryProps,
         });
+
         // Helper functions to report failures and return.
         const getFailMessage =
             (errorCode: keyof typeof summarizeErrors) => `${errorCode}: ${summarizeErrors[errorCode]}`;
@@ -231,10 +240,15 @@ export class SummaryGenerator {
 
         // Wait to generate and send summary
         this.summarizeTimer.start();
+
         // Use record type to prevent unexpected value types
         let summaryData: SubmitSummaryResult | undefined;
-        let generateTelemetryProps: Record<string, string | number | boolean | undefined> = {};
         try {
+            const generateSummaryEvent = PerformanceEvent.start(logger, {
+                eventName: "Summarize",
+                ...summarizeTelemetryProps,
+            });
+
             summaryData = await this.submitSummaryCallback({
                 fullTree,
                 refreshLatestAck,
@@ -243,29 +257,32 @@ export class SummaryGenerator {
             });
 
             // Cumulatively add telemetry properties based on how far generateSummary went.
-            const { referenceSequenceNumber: refSequenceNumber } = summaryData;
-            generateTelemetryProps = {
-                referenceSequenceNumber: refSequenceNumber,
-                opsSinceLastAttempt: refSequenceNumber - this.heuristicData.lastAttempt.refSequenceNumber,
-                opsSinceLastSummary: refSequenceNumber - this.heuristicData.lastSuccessfulSummary.refSequenceNumber,
+            const referenceSequenceNumber = summaryData.referenceSequenceNumber;
+            const opsSinceLastSummary =
+                referenceSequenceNumber - this.heuristicData.lastSuccessfulSummary.refSequenceNumber;
+            summarizeTelemetryProps = {
+                ...summarizeTelemetryProps,
+                referenceSequenceNumber,
+                opsSinceLastAttempt: referenceSequenceNumber - this.heuristicData.lastAttempt.refSequenceNumber,
+                opsSinceLastSummary,
             };
             if (summaryData.stage !== "base") {
-                generateTelemetryProps = {
-                    ...generateTelemetryProps,
+                summarizeTelemetryProps = {
+                    ...summarizeTelemetryProps,
                     ...summaryData.summaryStats,
                     generateDuration: summaryData.generateDuration,
                 };
 
                 if (summaryData.stage !== "generate") {
-                    generateTelemetryProps = {
-                        ...generateTelemetryProps,
+                    summarizeTelemetryProps = {
+                        ...summarizeTelemetryProps,
                         handle: summaryData.handle,
                         uploadDuration: summaryData.uploadDuration,
                     };
 
                     if (summaryData.stage !== "upload") {
-                        generateTelemetryProps = {
-                            ...generateTelemetryProps,
+                        summarizeTelemetryProps = {
+                            ...summarizeTelemetryProps,
                             clientSequenceNumber: summaryData.clientSequenceNumber,
                         };
                     }
@@ -273,11 +290,33 @@ export class SummaryGenerator {
             }
 
             if (summaryData.stage !== "submit") {
-                return fail("submitSummaryFailure", summaryData.error, generateTelemetryProps);
+                return fail("submitSummaryFailure", summaryData.error, summarizeTelemetryProps);
+            }
+
+            /**
+             * With incremental summaries, if the full tree was not summarized, only data stores that changed should
+             * be summarized. A data store is considered changed if either or both of the following is true:
+             * - It has received an op.
+             * - Its reference state changed, i.e., it went from referenced to unreferenced or vice-versa.
+             *
+             * In the extreme case, every op can be for a different data store and each op can result in the reference
+             * state change of multiple data stores. So, the total number of data stores that are summarized should not
+             * exceed the number of ops since last summary + number of data store whose reference state changed.
+             */
+            if (!fullTree && !summaryData.forcedFullTree) {
+                const { summarizedDataStoreCount, gcStateUpdatedDataStoreCount = 0 } = summaryData.summaryStats;
+                if (summarizedDataStoreCount > gcStateUpdatedDataStoreCount + opsSinceLastSummary) {
+                    logger.sendErrorEvent({
+                        eventName: "IncrementalSummaryViolation",
+                        summarizedDataStoreCount,
+                        gcStateUpdatedDataStoreCount,
+                        opsSinceLastSummary,
+                    });
+                }
             }
 
             // Log event here on summary success only, as Summarize_cancel duplicates failure logging.
-            logger.sendTelemetryEvent({ eventName: "GenerateSummary", ...generateTelemetryProps });
+            generateSummaryEvent.reportEvent("generate", {...summarizeTelemetryProps});
             resultsBuilder.summarySubmitted.resolve({ success: true, data: summaryData });
         } catch (error) {
             return fail("submitSummaryFailure", error);
@@ -305,9 +344,10 @@ export class SummaryGenerator {
                 success: true,
                 data: { summarizeOp, broadcastDuration },
             });
+
             this.heuristicData.lastAttempt.summarySequenceNumber = summarizeOp.sequenceNumber;
             logger.sendTelemetryEvent({
-                eventName: "SummaryOp",
+                eventName: "Summarize_Op",
                 duration: broadcastDuration,
                 referenceSequenceNumber: summarizeOp.referenceSequenceNumber,
                 summarySequenceNumber: summarizeOp.sequenceNumber,
@@ -327,14 +367,22 @@ export class SummaryGenerator {
 
             // Update for success/failure
             const ackNackDuration = Date.now() - this.heuristicData.lastAttempt.summaryTime;
-            const telemetryProps: Record<string, number> = {
+
+            // adding new properties
+            summarizeTelemetryProps = {
                 ackWaitDuration: ackNackDuration,
-                sequenceNumber: ackNackOp.sequenceNumber,
+                ackNackSequenceNumber: ackNackOp.sequenceNumber,
                 summarySequenceNumber: ackNackOp.contents.summaryProposal.summarySequenceNumber,
+                ...summarizeTelemetryProps,
             };
             if (ackNackOp.type === MessageType.SummaryAck) {
                 this.heuristicData.markLastAttemptAsSuccessful();
-                summarizeEvent.end({ ...telemetryProps, handle: ackNackOp.contents.handle, message: "summaryAck" });
+                this.successfulSummaryCallback();
+                summarizeEvent.end({
+                    ...summarizeTelemetryProps,
+                    handle: ackNackOp.contents.handle,
+                    message: "summaryAck",
+                });
                 resultsBuilder.receivedSummaryAckOrNack.resolve({ success: true, data: {
                     summaryAckOp: ackNackOp,
                     ackNackDuration,
@@ -348,13 +396,14 @@ export class SummaryGenerator {
 
                 const error = new LoggingError(`summaryNack: ${message}`, { retryAfterSeconds });
                 logger.sendErrorEvent(
-                    { eventName: "SummaryNack", ...generateTelemetryProps, retryAfterSeconds }, error);
+                    { eventName: "SummaryNack", ...summarizeTelemetryProps, retryAfterSeconds }, error);
+
                 assert(getRetryDelaySecondsFromError(error) === retryAfterSeconds, 0x25f /* "retryAfterSeconds" */);
                 // This will only set resultsBuilder.receivedSummaryAckOrNack, as other promises are already set.
                 return fail(
                     "summaryNack",
                     error,
-                    { ...telemetryProps, nackRetryAfter: retryAfterSeconds },
+                    { ...summarizeTelemetryProps, nackRetryAfter: retryAfterSeconds },
                     { summaryNackOp: ackNackOp, ackNackDuration },
                 );
             }