@fluidframework/container-runtime 1.2.3-83900 → 2.0.0-internal.1.0.0

package/src/runningSummarizer.ts

@@ -6,6 +6,7 @@
 import { IDisposable, ITelemetryLogger } from "@fluidframework/common-definitions";
 import { assert, delay, Deferred, PromiseTimer } from "@fluidframework/common-utils";
 import { UsageError } from "@fluidframework/container-utils";
+import { isRuntimeMessage } from "@fluidframework/driver-utils";
 import {
     ISequencedDocumentMessage,
     MessageType,
@@ -14,6 +15,7 @@ import { ChildLogger } from "@fluidframework/telemetry-utils";
 import {
     ISummaryConfiguration,
 } from "./containerRuntime";
+import { opSize } from "./opProperties";
 import { SummarizeHeuristicRunner } from "./summarizerHeuristics";
 import {
     IEnqueueSummarizeOptions,
@@ -28,6 +30,7 @@ import {
     ISummaryCancellationToken,
     ISummarizeResults,
     ISummarizeTelemetryProperties,
+    ISummarizerRuntime,
     ISummarizeRunnerTelemetry,
 } from "./summarizerTypes";
 import { IClientSummaryWatcher, SummaryCollection } from "./summaryCollection";
@@ -58,6 +61,7 @@ export class RunningSummarizer implements IDisposable {
         summaryCollection: SummaryCollection,
         cancellationToken: ISummaryCancellationToken,
         stopSummarizerCallback: (reason: SummarizerStopReason) => void,
+        runtime: ISummarizerRuntime,
     ): Promise<RunningSummarizer> {
         const summarizer = new RunningSummarizer(
             logger,
@@ -68,20 +72,44 @@ export class RunningSummarizer implements IDisposable {
             raiseSummarizingError,
             summaryCollection,
             cancellationToken,
-            stopSummarizerCallback);
+            stopSummarizerCallback,
+            runtime);
 
         await summarizer.waitStart();
 
-        // Run the heuristics after starting
+        // Update heuristic counts
+        // By the time we get here, there are potentially ops missing from the heuristic summary counts
+        // Examples of where this could happen:
+        // 1. Op is processed during the time that we are initiating the RunningSummarizer instance but before we
+        //    listen for the op events (will get missed by the handlers in the current workflow)
+        // 2. Op was sequenced after the last time we summarized (op sequence number > summarize ref sequence number)
+        const diff = runtime.deltaManager.lastSequenceNumber - (
+            heuristicData.lastSuccessfulSummary.refSequenceNumber
+            + heuristicData.numNonRuntimeOps
+            + heuristicData.numRuntimeOps);
+        heuristicData.hasMissingOpData = diff > 0;
+
+        if (heuristicData.hasMissingOpData) {
+            // Split the diff 50-50 and increment the counts appropriately
+            heuristicData.numNonRuntimeOps += Math.ceil(diff / 2);
+            heuristicData.numRuntimeOps += Math.floor(diff / 2);
+        }
+
+        // Update last seq number (in case the handlers haven't processed anything yet)
+        heuristicData.lastOpSequenceNumber = runtime.deltaManager.lastSequenceNumber;
+
+        // Start heuristics
+        summarizer.heuristicRunner?.start();
         summarizer.heuristicRunner?.run();
+
         return summarizer;
     }
 
     public get disposed() { return this._disposed; }
-
     private stopping = false;
     private _disposed = false;
     private summarizingLock: Promise<void> | undefined;
+    private refreshSummaryAckLock: Promise<void> | undefined;
     private tryWhileSummarizing = false;
     private readonly pendingAckTimer: PromiseTimer;
     private heuristicRunner?: ISummarizeHeuristicRunner;
@@ -95,6 +123,7 @@ export class RunningSummarizer implements IDisposable {
     } | undefined;
     private summarizeCount = 0;
     private totalSuccessfulAttempts = 0;
+    private initialized = false;
 
     private constructor(
         baseLogger: ITelemetryLogger,
@@ -106,6 +135,7 @@ export class RunningSummarizer implements IDisposable {
         private readonly summaryCollection: SummaryCollection,
         private readonly cancellationToken: ISummaryCancellationToken,
         private readonly stopSummarizerCallback: (reason: SummarizerStopReason) => void,
+        private readonly runtime: ISummarizerRuntime,
     ) {
         const telemetryProps: ISummarizeRunnerTelemetry = {
             summarizeCount: () => this.summarizeCount,
@@ -175,9 +205,13 @@ export class RunningSummarizer implements IDisposable {
             this.summaryWatcher,
             this.logger,
         );
+
+        // Listen for ops
+        this.runtime.deltaManager.on("op", (op) => { this.handleOp(op); });
     }
 
     public dispose(): void {
+        this.runtime.deltaManager.off("op", (op) => { this.handleOp(op); });
         this.summaryWatcher.dispose();
         this.heuristicRunner?.dispose();
         this.heuristicRunner = undefined;
@@ -199,30 +233,48 @@ export class RunningSummarizer implements IDisposable {
             ? this.logger
             : undefined;
 
-    public handleSystemOp(op: ISequencedDocumentMessage) {
-        switch (op.type) {
-            case MessageType.ClientLeave:
-            case MessageType.ClientJoin:
-            case MessageType.Propose: {
-                // Synchronously handle quorum ops like regular ops
-                this.handleOp(undefined, op);
-                return;
-            }
-            default: {
-                return;
-            }
-        }
-    }
+    /** We only want a single heuristic runner micro-task (will provide better optimized grouping of ops) */
+    private heuristicRunnerMicroTaskExists = false;
 
-    public handleOp(error: any, { sequenceNumber, type, clientId, contents }: ISequencedDocumentMessage) {
-        if (error !== undefined) {
-            return;
+    public handleOp(op: ISequencedDocumentMessage) {
+        this.heuristicData.lastOpSequenceNumber = op.sequenceNumber;
+
+        if (op.type !== MessageType.Summarize && isRuntimeMessage(op)) {
+            this.heuristicData.numRuntimeOps++;
+        } else {
+            this.heuristicData.numNonRuntimeOps++;
         }
-        this.heuristicData.lastOpSequenceNumber = sequenceNumber;
+
+        this.heuristicData.totalOpsSize += opSize(op);
 
         // Check for enqueued on-demand summaries; Intentionally do nothing otherwise
-        if (!this.tryRunEnqueuedSummary()) {
-            this.heuristicRunner?.run();
+        if (this.initialized
+            && this.opCanTriggerSummary(op)
+            && !this.tryRunEnqueuedSummary()
+            && !this.heuristicRunnerMicroTaskExists) {
+            this.heuristicRunnerMicroTaskExists = true;
+            Promise.resolve().then(() => {
+                this.heuristicRunner?.run();
+            }).finally(() => {
+                this.heuristicRunnerMicroTaskExists = false;
+            });
+        }
+    }
+
+    /**
+     * Can the given op trigger a summary?
+     * # Currently only prevents summaries for Summarize and SummaryAck ops
+     * @param op - op to check
+     * @returns true if this type of op can trigger a summary
+     */
+    private opCanTriggerSummary(op: ISequencedDocumentMessage): boolean {
+        switch (op.type) {
+            case MessageType.Summarize:
+            case MessageType.SummaryAck:
+            case MessageType.SummaryNack:
+                return false;
+            default:
+                return true;
         }
     }
 
@@ -274,6 +326,32 @@ export class RunningSummarizer implements IDisposable {
                 summarySequenceNumber: waitStartResult.value.summaryOp.sequenceNumber,
             });
         }
+        this.initialized = true;
+    }
+
+    /**
+     * Blocks a new summarizer from running in case RefreshSummaryAck is being processed.
+     * Assumes that caller checked upfront for lack of concurrent action (this.refreshSummaryAckLock)
+     * before calling this API. I.e. caller is responsible for either erroring out or waiting on this promise.
+     * Note: The refreshSummaryAckLock makes sure no summarizer gets enqueued or processed
+     * until the refresh has completed. One can't rely uniquely on the summarizingLock as the
+     * refreshLatestSummaryAck also happens during the time summarizingLock !== undefined.
+     * Ex. Summarizer submits a summay + op and then waits for the Summary Ack to proceed
+     * with the refreshLatestSummaryAck and complete the summary.
+     * @param action - action to perform.
+     * @returns - result of action.
+     */
+    public async lockedRefreshSummaryAckAction<T>(action: () => Promise<T>) {
+        assert(this.refreshSummaryAckLock === undefined,
+            0x396 /* Refresh Summary Ack - Caller is responsible for checking lock */);
+
+        const refreshSummaryAckLock = new Deferred<void>();
+        this.refreshSummaryAckLock = refreshSummaryAckLock.promise;
+
+        return action().finally(() => {
+            refreshSummaryAckLock.resolve();
+            this.refreshSummaryAckLock = undefined;
+        });
     }
 
     /**
@@ -290,6 +368,8 @@ export class RunningSummarizer implements IDisposable {
         this.summarizingLock = summarizingLock.promise;
 
         this.summarizeCount++;
+        // Make sure the RefreshLatestSummaryAck is not being executed.
+        await this.refreshSummaryAckLock;
 
         return action().finally(() => {
             summarizingLock.resolve();
@@ -393,6 +473,10 @@ export class RunningSummarizer implements IDisposable {
                     });
                     await delay(delaySeconds * 1000);
                 }
+
+                // Make sure the refresh Summary Ack is not being executed.
+                await this.refreshSummaryAckLock;
+
                 // 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, cancellationToken);
@@ -441,6 +525,7 @@ export class RunningSummarizer implements IDisposable {
             // The heuristics are blocking concurrent summarize attempts.
             throw new UsageError("Attempted to run an already-running summarizer on demand");
         }
+
         const result = this.trySummarizeOnce(
             { reason: `onDemand/${reason}` },
             options,

package/src/summarizer.ts

@@ -8,22 +8,25 @@ 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 { DriverHeader } from "@fluidframework/driver-definitions";
+import { DriverErrorType, DriverHeader } from "@fluidframework/driver-definitions";
 import { requestFluidObject } from "@fluidframework/runtime-utils";
-import { ChildLogger, IFluidErrorBase, LoggingError, wrapErrorAndLog } from "@fluidframework/telemetry-utils";
+import {
+    ChildLogger,
+    IFluidErrorBase,
+    isFluidError,
+    LoggingError,
+    wrapErrorAndLog,
+} from "@fluidframework/telemetry-utils";
 import {
     FluidObject,
     IFluidHandleContext,
     IFluidHandle,
     IRequest,
 } from "@fluidframework/core-interfaces";
-import {
-    ISequencedDocumentMessage,
-} from "@fluidframework/protocol-definitions";
 import { ISummaryConfiguration } from "./containerRuntime";
 import { ICancellableSummarizerController } from "./runWhileConnectedCoordinator";
 import { summarizerClientType } from "./summarizerClientElection";
-import { SummaryCollection } from "./summaryCollection";
+import { IAckedSummary, SummaryCollection } from "./summaryCollection";
 import { SummarizerHandle } from "./summarizerHandle";
 import { RunningSummarizer } from "./runningSummarizer";
 import {
@@ -70,8 +73,6 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 
     private readonly logger: ITelemetryLogger;
     private runningSummarizer?: RunningSummarizer;
-    private systemOpListener?: (op: ISequencedDocumentMessage) => void;
-    private opListener?: (error: any, op: ISequencedDocumentMessage) => void;
     private _disposed: boolean = false;
     private starting: boolean = false;
 
@@ -277,6 +278,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
             this.summaryCollection,
             runCoordinator /* cancellationToken */,
             (reason) => runCoordinator.stop(reason), /* stopSummarizerCallback */
+            this.runtime,
         );
         this.runningSummarizer = runningSummarizer;
         this.starting = false;
@@ -287,13 +289,6 @@ export class Summarizer extends EventEmitter implements ISummarizer {
             this.logger.sendErrorEvent({ eventName: "HandleSummaryAckFatalError" }, error);
         });
 
-        // Listen for ops
-        this.systemOpListener = (op: ISequencedDocumentMessage) => runningSummarizer.handleSystemOp(op);
-        this.runtime.deltaManager.inbound.on("op", this.systemOpListener);
-
-        this.opListener = (error: any, op: ISequencedDocumentMessage) => runningSummarizer.handleOp(error, op);
-        this.runtime.on("batchEnd", this.opListener);
-
         return runningSummarizer;
     }
 
@@ -312,12 +307,6 @@ export class Summarizer extends EventEmitter implements ISummarizer {
             this.runningSummarizer.dispose();
             this.runningSummarizer = undefined;
         }
-        if (this.systemOpListener) {
-            this.runtime.deltaManager.inbound.off("op", this.systemOpListener);
-        }
-        if (this.opListener) {
-            this.runtime.removeListener("batchEnd", this.opListener);
-        }
     }
 
     public readonly summarizeOnDemand: ISummarizer["summarizeOnDemand"] = (...args) => {
@@ -378,22 +367,52 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 
     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 {
-                const ack = await this.summaryCollection.waitSummaryAck(refSequenceNumber);
+                // 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;
-
-                await this.internalsProvider.refreshLatestSummaryAck(
-                    ack.summaryOp.contents.handle,
-                    ack.summaryAck.contents.handle,
-                    refSequenceNumber,
-                    summaryLogger,
+                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(
+                        summaryOpHandle,
+                        summaryAckHandle,
+                        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

@@ -6,11 +6,11 @@
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { Timer } from "@fluidframework/common-utils";
 import { ISummaryConfigurationHeuristics } from "./containerRuntime";
-
 import {
     ISummarizeHeuristicData,
     ISummarizeHeuristicRunner,
     ISummarizeAttempt,
+    ISummaryHeuristicStrategy,
 } from "./summarizerTypes";
 import { SummarizeReason } from "./summaryGenerator";
 
@@ -26,6 +26,30 @@ export class SummarizeHeuristicData implements ISummarizeHeuristicData {
         return this._lastSuccessfulSummary;
     }
 
+    public numNonRuntimeOps: number = 0;
+    public totalOpsSize: number = 0;
+    public hasMissingOpData: boolean = false;
+
+    /**
+     * Cumulative size in bytes of all the ops at the beginning of the summarization attempt.
+     * Is used to adjust totalOpsSize appropriately after successful summarization.
+     */
+     /** */
+    private totalOpsSizeBefore: number = 0;
+
+    /**
+     * Number of system ops at beginning of attempting to summarize.
+     * Is used to adjust numSystemOps appropriately after successful summarization.
+     */
+    private numSystemOpsBefore: number = 0;
+
+    public numRuntimeOps: number = 0;
+    /**
+     * Number of non-system ops at beginning of attempting to summarize.
+     * Is used to adjust numNonSystemOps appropriately after successful summarization.
+     */
+    private numNonSystemOpsBefore: number = 0;
+
     constructor(
         public lastOpSequenceNumber: number,
         /** Baseline attempt data used for comparisons with subsequent attempts/calculations. */
@@ -45,10 +69,23 @@ export class SummarizeHeuristicData implements ISummarizeHeuristicData {
             refSequenceNumber: refSequenceNumber ?? this.lastOpSequenceNumber,
             summaryTime: Date.now(),
         };
+
+        this.numSystemOpsBefore = this.numNonRuntimeOps;
+        this.numNonSystemOpsBefore = this.numRuntimeOps;
+        this.totalOpsSizeBefore = this.totalOpsSize;
     }
 
     public markLastAttemptAsSuccessful() {
         this._lastSuccessfulSummary = { ...this.lastAttempt };
+
+        this.numNonRuntimeOps -= this.numSystemOpsBefore;
+        this.numSystemOpsBefore = 0;
+
+        this.numRuntimeOps -= this.numNonSystemOpsBefore;
+        this.numNonSystemOpsBefore = 0;
+
+        this.totalOpsSize -= this.totalOpsSizeBefore;
+        this.totalOpsSizeBefore = 0;
     }
 }
 
@@ -56,42 +93,71 @@ export class SummarizeHeuristicData implements ISummarizeHeuristicData {
  * This class contains the heuristics for when to summarize.
  */
 export class SummarizeHeuristicRunner implements ISummarizeHeuristicRunner {
-    private readonly idleTimer: Timer;
-    private readonly minOpsForLastSummaryAttempt: number;
+    private readonly idleTimer: Timer | undefined;
+    private readonly runSummarize: (reason: SummarizeReason) => void;
 
     public constructor(
         private readonly heuristicData: ISummarizeHeuristicData,
         private readonly configuration: ISummaryConfigurationHeuristics,
-        private readonly trySummarize: (reason: SummarizeReason) => void,
+        trySummarize: (reason: SummarizeReason) => void,
         private readonly logger: ITelemetryLogger,
+        private readonly summarizeStrategies: ISummaryHeuristicStrategy[] = getDefaultSummaryHeuristicStrategies(),
     ) {
         this.idleTimer = new Timer(
-            this.configuration.idleTime,
-            () => this.trySummarize("idle"));
-        this.minOpsForLastSummaryAttempt = this.configuration.minOpsForLastSummaryAttempt;
+            this.idleTime,
+            () => this.runSummarize("idle"));
+
+        this.runSummarize = (reason: SummarizeReason) => {
+            this.idleTimer?.clear();
+
+            // We shouldn't attempt a summary if there are no new processed ops
+            const opsSinceLastAck = this.opsSinceLastAck;
+            if (opsSinceLastAck > 0) {
+                trySummarize(reason);
+            }
+        };
+    }
+
+    public get idleTime(): number {
+        const maxIdleTime = this.configuration.maxIdleTime;
+        const minIdleTime = this.configuration.minIdleTime;
+        const weightedNumOfOps = getWeightedNumberOfOps(
+            this.heuristicData.numRuntimeOps,
+            this.heuristicData.numNonRuntimeOps,
+            this.configuration.runtimeOpWeight,
+            this.configuration.nonRuntimeOpWeight,
+        );
+        const pToMaxOps = weightedNumOfOps * 1.0 / this.configuration.maxOps;
+
+        if (pToMaxOps >= 1) {
+            return minIdleTime;
+        }
+
+        // Return a ratioed idle time based on the percentage of ops
+        return maxIdleTime - ((maxIdleTime - minIdleTime) * pToMaxOps);
     }
 
     public get opsSinceLastAck(): number {
         return this.heuristicData.lastOpSequenceNumber - this.heuristicData.lastSuccessfulSummary.refSequenceNumber;
     }
 
+    public start() {
+        this.idleTimer?.start(this.idleTime);
+    }
+
     public run() {
-        const timeSinceLastSummary = Date.now() - this.heuristicData.lastSuccessfulSummary.summaryTime;
-        const opsSinceLastAck = this.opsSinceLastAck;
-        if (timeSinceLastSummary > this.configuration.maxTime) {
-            this.idleTimer.clear();
-            this.trySummarize("maxTime");
-        } else if (opsSinceLastAck > this.configuration.maxOps) {
-            this.idleTimer.clear();
-            this.trySummarize("maxOps");
-        } else {
-            this.idleTimer.restart();
+        for (const strategy of this.summarizeStrategies) {
+            if (strategy.shouldRunSummary(this.configuration, this.heuristicData)) {
+                return this.runSummarize(strategy.summarizeReason);
+            }
         }
+
+        this.idleTimer?.restart(this.idleTime);
     }
 
     public shouldRunLastSummary(): boolean {
         const opsSinceLastAck = this.opsSinceLastAck;
-        const minOpsForLastSummaryAttempt = this.minOpsForLastSummaryAttempt;
+        const minOpsForLastSummaryAttempt = this.configuration.minOpsForLastSummaryAttempt;
 
         this.logger.sendTelemetryEvent({
             eventName: "ShouldRunLastSummary",
@@ -103,6 +169,54 @@ export class SummarizeHeuristicRunner implements ISummarizeHeuristicRunner {
     }
 
     public dispose() {
-        this.idleTimer.clear();
+        this.idleTimer?.clear();
+    }
+}
+
+/** Strategy used to run a summary when it's been a while since our last successful summary */
+class MaxTimeSummaryHeuristicStrategy implements ISummaryHeuristicStrategy {
+    public readonly summarizeReason: Readonly<SummarizeReason> = "maxTime";
+
+    public shouldRunSummary(
+        configuration: ISummaryConfigurationHeuristics,
+        heuristicData: ISummarizeHeuristicData,
+    ): boolean {
+        const timeSinceLastSummary = Date.now() - heuristicData.lastSuccessfulSummary.summaryTime;
+        return timeSinceLastSummary > configuration.maxTime;
     }
 }
+
+function getWeightedNumberOfOps(
+    runtimeOpCount: number,
+    nonRuntimeOpCount: number,
+    runtimeOpWeight: number,
+    nonRuntimeOpWeight: number,
+): number {
+    return (runtimeOpWeight * runtimeOpCount)
+         + (nonRuntimeOpWeight * nonRuntimeOpCount);
+}
+
+/** Strategy used to do a weighted analysis on the ops we've processed since the last successful summary */
+class WeightedOpsSummaryHeuristicStrategy implements ISummaryHeuristicStrategy {
+    public readonly summarizeReason: Readonly<SummarizeReason> = "maxOps";
+
+    public shouldRunSummary(
+        configuration: ISummaryConfigurationHeuristics,
+        heuristicData: ISummarizeHeuristicData,
+    ): boolean {
+        const weightedNumOfOps = getWeightedNumberOfOps(
+            heuristicData.numRuntimeOps,
+            heuristicData.numNonRuntimeOps,
+            configuration.runtimeOpWeight,
+            configuration.nonRuntimeOpWeight,
+        );
+        return weightedNumOfOps > configuration.maxOps;
+    }
+}
+
+function getDefaultSummaryHeuristicStrategies() {
+    return [
+        new MaxTimeSummaryHeuristicStrategy(),
+        new WeightedOpsSummaryHeuristicStrategy(),
+    ];
+}

package/src/summarizerTypes.ts

@@ -21,6 +21,8 @@ import {
 } from "@fluidframework/protocol-definitions";
 import { ISummaryStats } from "@fluidframework/runtime-definitions";
 import { ISummaryAckMessage, ISummaryNackMessage, ISummaryOpMessage } from "./summaryCollection";
+import { SummarizeReason } from "./summaryGenerator";
+import { ISummaryConfigurationHeuristics } from ".";
 
 /**
  * @deprecated - This will be removed in a later release.
@@ -98,7 +100,9 @@ export interface ISummarizerRuntime extends IConnectableRuntime {
     /** clientId of parent (non-summarizing) container that owns summarizer container */
     readonly summarizerClientId: string | undefined;
     closeFn(): void;
+    /** @deprecated 1.0, please remove all implementations and usage */
     on(event: "batchEnd", listener: (error: any, op: ISequencedDocumentMessage) => void): this;
+    /** @deprecated 1.0, please remove all implementations and usage */
     removeListener(event: "batchEnd", listener: (error: any, op: ISequencedDocumentMessage) => void): this;
 }
 
@@ -150,10 +154,6 @@ export interface IGeneratedSummaryStats extends ISummaryStats {
     readonly gcTotalBlobsSize?: number;
     /** The number of gc blobs in this summary. */
     readonly gcBlobNodeCount?: number;
-    /** Sum of the sizes of all op contents since the last summary */
-    readonly opsSizesSinceLastSummary: number;
-    /** Number of non-system ops since the last summary. See {@link @fluidframework/protocol-base#isSystemMessage} */
-    readonly nonSystemOpsSinceLastSummary: number;
     /** The summary number for a container's summary. Incremented on summaries throughout its lifetime. */
     readonly summaryNumber: number;
 }
@@ -361,6 +361,18 @@ export interface ISummarizeHeuristicData {
     /** Most recent summary that received an ack */
     readonly lastSuccessfulSummary: Readonly<ISummarizeAttempt>;
 
+    /** Number of runtime ops since last summary */
+    numRuntimeOps: number;
+
+    /** Number of non-runtime ops since last summary */
+    numNonRuntimeOps: number;
+
+    /** Cumulative size in bytes of all the ops since the last summary */
+    totalOpsSize: number;
+
+    /** Wether or not this instance contains adjusted metrics due to missing op data */
+    hasMissingOpData: boolean;
+
     /**
      * Updates lastAttempt and lastSuccessfulAttempt based on the last summary.
      * @param lastSummary - last ack summary
@@ -381,7 +393,10 @@ export interface ISummarizeHeuristicData {
 
 /** Responsible for running heuristics determining when to summarize. */
 export interface ISummarizeHeuristicRunner {
-    /** Runs the heuristic to determine if it should try to summarize */
+    /** Start specific heuristic trackers (ex: idle timer) */
+    start(): void;
+
+    /** Runs the heuristics to determine if it should try to summarize */
     run(): void;
 
     /** Runs a different heuristic to check if it should summarize before closing */
@@ -408,6 +423,19 @@ export type ISummarizeTelemetryProperties =
     Pick<ITelemetryProperties, ISummarizeTelemetryRequiredProperties> &
     Partial<Pick<ITelemetryProperties, ISummarizeTelemetryOptionalProperties>>;
 
+/** Strategy used to heuristically determine when we should run a summary */
+export interface ISummaryHeuristicStrategy {
+    /** Summarize reason for this summarize heuristic strategy (ex: "maxTime") */
+    summarizeReason: Readonly<SummarizeReason>;
+
+    /**
+     * Determines if this strategy's summarize criteria been met
+     * @param configuration - summary configuration we are to check against
+     * @param heuristicData - heuristic data used to confirm conditions are met
+     */
+    shouldRunSummary(configuration: ISummaryConfigurationHeuristics, heuristicData: ISummarizeHeuristicData): boolean;
+}
+
 type SummaryGeneratorRequiredTelemetryProperties =
     /** True to generate the full tree with no handle reuse optimizations */
     "fullTree" |
@@ -428,11 +456,10 @@ type SummaryGeneratorOptionalTelemetryProperties =
     /** Delta in sum of op sizes between the current reference sequence number and the reference
      *  sequence number of the last summary */
     "opsSizesSinceLastSummary" |
-    /**
-     * Delta between the number of non-system ops since the last summary.
-     * See {@link @fluidframework/protocol-base#isSystemMessage}
-     */
-    "nonSystemOpsSinceLastSummary" |
+    /** Delta between the number of non-runtime ops since the last summary */
+    "nonRuntimeOpsSinceLastSummary" |
+    /** Wether or not this instance contains adjusted metrics due to missing op data */
+    "hasMissingOpData" |
     /** Time it took to generate the summary tree and stats. */
     "generateDuration" |
     /** The handle returned by storage pointing to the uploaded summary tree. */