@fluidframework/container-runtime 1.2.2 → 2.0.0-internal.1.0.0.82159

package/src/dataStore.ts

@@ -43,7 +43,8 @@ export const channelToDataStore = (
     runtime: ContainerRuntime,
     datastores: DataStores,
     logger: ITelemetryLogger,
-): IDataStore => new DataStore(fluidDataStoreChannel, internalId, runtime, datastores, logger);
+    alreadyAliased: boolean = false,
+): IDataStore => new DataStore(fluidDataStoreChannel, internalId, runtime, datastores, logger, alreadyAliased);
 
 enum AliasState {
     Aliased = "Aliased",
@@ -54,6 +55,7 @@ enum AliasState {
 class DataStore implements IDataStore {
     private aliasState: AliasState = AliasState.None;
     private alias: string | undefined;
+    private readonly pendingAliases: Map<string, Promise<AliasResult>>;
     private aliasResult: Promise<AliasResult> | undefined;
 
     async trySetAlias(alias: string): Promise<AliasResult> {
@@ -75,14 +77,25 @@ class DataStore implements IDataStore {
             case AliasState.Aliased:
                 return this.alias === alias ? "Success" : "AlreadyAliased";
 
-            // There is no current or past alias operation for this datastore,
-            // it is safe to continue execution
-            case AliasState.None: break;
+            case AliasState.None: {
+                const existingAlias = this.pendingAliases.get(alias);
+                if (existingAlias !== undefined) {
+                    // There is already another datastore which will be aliased
+                    // to the same name
+                    return "Conflict";
+                }
+
+                // There is no current or past alias operation for this datastore,
+                // or for this alias, so it is safe to continue execution
+                break;
+            }
+
             default: unreachableCase(this.aliasState);
         }
 
         this.aliasState = AliasState.Aliasing;
         this.aliasResult = this.trySetAliasInternal(alias);
+        this.pendingAliases.set(alias, this.aliasResult);
         return this.aliasResult;
     }
 
@@ -92,13 +105,7 @@ class DataStore implements IDataStore {
             alias,
         };
 
-        // back-compat 0.58.2000 - makeVisibleAndAttachGraph was added in this version to IFluidDataStoreChannel. For
-        // older versions, we still have to call bindToContext.
-        if (this.fluidDataStoreChannel.makeVisibleAndAttachGraph !== undefined) {
-            this.fluidDataStoreChannel.makeVisibleAndAttachGraph();
-        } else {
-            this.fluidDataStoreChannel.bindToContext();
-        }
+        this.fluidDataStoreChannel.makeVisibleAndAttachGraph();
 
         if (this.runtime.attachState === AttachState.Detached) {
             const localResult = this.datastores.processAliasMessageCore(message);
@@ -108,34 +115,37 @@ class DataStore implements IDataStore {
             return localResult ? "Success" : "Conflict";
         }
 
-        const aliased = await this.ackBasedPromise<boolean>((resolve) => {
-            this.runtime.submitDataStoreAliasOp(message, resolve);
-        }).then((succeeded) => {
-            // Explicitly Lock-out future attempts of aliasing,
-            // regardless of result
-            this.aliasState = AliasState.Aliased;
-            if (succeeded) {
-                this.alias = alias;
-            }
-
-            return succeeded;
-        }).catch((error) => {
-            this.logger.sendErrorEvent({
-                eventName: "AliasingException",
-                alias: {
-                    value: alias,
-                    tag: TelemetryDataTag.UserData,
-                },
-                internalId: {
-                    value: this.internalId,
-                    tag: TelemetryDataTag.PackageData,
-                },
-            }, error);
+        const aliased = await this
+            .ackBasedPromise<boolean>((resolve) => {
+                this.runtime.submitDataStoreAliasOp(message, resolve);
+            })
+            .catch((error) => {
+                this.logger.sendErrorEvent({
+                    eventName: "AliasingException",
+                    alias: {
+                        value: alias,
+                        tag: TelemetryDataTag.UserData,
+                    },
+                    internalId: {
+                        value: this.internalId,
+                        tag: TelemetryDataTag.CodeArtifact,
+                    },
+                }, error);
+
+                return false;
+            }).finally(() => {
+                this.pendingAliases.delete(alias);
+            });
+
+        if (!aliased) {
             this.aliasState = AliasState.None;
-            return false;
-        });
+            this.aliasResult = undefined;
+            return "Conflict";
+        }
 
-        return aliased ? "Success" : "Conflict";
+        this.alias = alias;
+        this.aliasState = AliasState.Aliased;
+        return "Success";
     }
 
     async request(request: IRequest): Promise<IResponse> {
@@ -148,7 +158,12 @@ class DataStore implements IDataStore {
         private readonly runtime: ContainerRuntime,
         private readonly datastores: DataStores,
         private readonly logger: ITelemetryLogger,
-    ) { }
+        alreadyAliased: boolean,
+    ) {
+        this.pendingAliases = datastores.pendingAliases;
+        this.aliasState = alreadyAliased ? AliasState.Aliased : AliasState.None;
+    }
+
     public get IFluidRouter() { return this.fluidDataStoreChannel; }
 
     private async ackBasedPromise<T>(

package/src/dataStoreContext.ts

@@ -13,7 +13,6 @@ import {
 import {
     IAudience,
     IDeltaManager,
-    BindState,
     AttachState,
     ILoaderOptions,
 } from "@fluidframework/container-definitions";
@@ -232,7 +231,9 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
     protected registry: IFluidDataStoreRegistry | undefined;
 
     protected detachedRuntimeCreation = false;
-    public readonly bindToContext: () => void;
+    // back-compat (for tests) - can be removed in 2.0.0-alpha.2.0.0, or earlier if compat tests drop n/n-2 coverage
+    // @ts-expect-error - This shouldn't be referenced in the current version, but needs to be here for back-compat
+    private readonly bindToContext: () => void;
     protected channel: IFluidDataStoreChannel | undefined;
     private loaded = false;
     protected pending: ISequencedDocumentMessage[] | undefined = [];
@@ -260,7 +261,6 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
     constructor(
         props: IFluidDataStoreContextProps,
         private readonly existing: boolean,
-        private bindState: BindState,
         public readonly isLocalDataStore: boolean,
         private readonly makeLocallyVisibleFn: () => void,
     ) {
@@ -282,11 +282,8 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
             this.containerRuntime.attachState : AttachState.Detached;
 
         this.bindToContext = () => {
-            assert(this.bindState === BindState.NotBound, 0x13b /* "datastore context is already in bound state" */);
-            this.bindState = BindState.Binding;
             assert(this.channel !== undefined, 0x13c /* "undefined channel on datastore context" */);
             this.makeLocallyVisible();
-            this.bindState = BindState.Bound;
         };
 
         const thisSummarizeInternal =
@@ -319,7 +316,7 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
     }
 
     private rejectDeferredRealize(reason: string, packageName?: string): never {
-        throw new LoggingError(reason, { packageName: { value: packageName, tag: TelemetryDataTag.PackageData } });
+        throw new LoggingError(reason, { packageName: { value: packageName, tag: TelemetryDataTag.CodeArtifact } });
     }
 
     public async realize(): Promise<IFluidDataStoreChannel> {
@@ -328,7 +325,12 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
             this.channelDeferred = new Deferred<IFluidDataStoreChannel>();
             this.realizeCore(this.existing).catch((error) => {
                 const errorWrapped = DataProcessingError.wrapIfUnrecognized(error, "realizeFluidDataStoreContext");
-                errorWrapped.addTelemetryProperties({ fluidDataStoreId: { value: this.id, tag: "PackageData" } });
+                errorWrapped.addTelemetryProperties({
+                    fluidDataStoreId: {
+                        value: this.id,
+                        tag: TelemetryDataTag.CodeArtifact,
+                    },
+                });
                 this.channelDeferred?.reject(errorWrapped);
                 this.logger.sendErrorEvent({ eventName: "RealizeError" }, errorWrapped);
             });
@@ -690,7 +692,10 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
         } catch (error) {
             this.channelDeferred?.reject(error);
             this.logger.sendErrorEvent(
-                { eventName: "BindRuntimeError", fluidDataStoreId: { value: this.id, tag: "PackageData" } },
+                { eventName: "BindRuntimeError", fluidDataStoreId: {
+                    value: this.id,
+                    tag: TelemetryDataTag.CodeArtifact,
+                } },
                 error);
         }
     }
@@ -783,7 +788,6 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
         super(
             props,
             true /* existing */,
-            BindState.Bound,
             false /* isLocalDataStore */,
             () => {
                 throw new Error("Already attached");
@@ -809,11 +813,7 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
 
         const localReadAndParse = async <T>(id: string) => readAndParse<T>(this.storage, id);
         if (tree) {
-            const loadedSummary = await this.summarizerNode.loadBaseSummary(tree, localReadAndParse);
-            tree = loadedSummary.baseSummary;
-            // Prepend outstanding ops to pending queue of ops to process.
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            this.pending = loadedSummary.outstandingOps.concat(this.pending!);
+            tree = await this.summarizerNode.loadBaseSummary(tree, localReadAndParse);
         }
 
         if (!!tree && tree.blobs[dataStoreAttributesBlobName] !== undefined) {
@@ -892,7 +892,6 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
         super(
             props,
             props.snapshotTree !== undefined ? true : false /* existing */,
-            props.snapshotTree ? BindState.Bound : BindState.NotBound,
             true /* isLocalDataStore */,
             props.makeLocallyVisibleFn,
         );
@@ -1040,13 +1039,7 @@ export class LocalDetachedFluidDataStoreContext
         super.bindRuntime(dataStoreChannel);
 
         if (await this.isRoot()) {
-            // back-compat 0.59.1000 - makeVisibleAndAttachGraph was added in this version to IFluidDataStoreChannel.
-            // For older versions, we still have to call bindToContext.
-            if (dataStoreChannel.makeVisibleAndAttachGraph !== undefined) {
-                dataStoreChannel.makeVisibleAndAttachGraph();
-            } else {
-                dataStoreChannel.bindToContext();
-            }
+            dataStoreChannel.makeVisibleAndAttachGraph();
         }
     }
 

package/src/dataStores.ts

@@ -12,6 +12,7 @@ import {
     ISnapshotTree,
 } from "@fluidframework/protocol-definitions";
 import {
+    AliasResult,
     channelsTreeName,
     CreateChildSummarizerNodeFn,
     CreateChildSummarizerNodeParam,
@@ -82,6 +83,7 @@ export class DataStores implements IDisposable {
     // The handle to the container runtime. This is used mainly for GC purposes to represent outbound reference from
     // the container runtime to other nodes.
     private readonly containerRuntimeHandle: IFluidHandle;
+    private readonly pendingAliasMap: Map<string, Promise<AliasResult>> = new Map<string, Promise<AliasResult>>();
 
     constructor(
         private readonly baseSnapshot: ISnapshotTree | undefined,
@@ -173,10 +175,19 @@ export class DataStores implements IDisposable {
         };
     }
 
-    public aliases(): ReadonlyMap<string, string> {
+    public get aliases(): ReadonlyMap<string, string> {
         return this.aliasMap;
     }
 
+    public get pendingAliases(): Map<string, Promise<AliasResult>> {
+        return this.pendingAliasMap;
+    }
+
+    public async waitIfPendingAlias(maybeAlias: string): Promise<AliasResult> {
+        const pendingAliasPromise = this.pendingAliases.get(maybeAlias);
+        return pendingAliasPromise === undefined ? "Success" : pendingAliasPromise;
+    }
+
     public processAttachMessage(message: ISequencedDocumentMessage, local: boolean) {
         const attachMessage = message.contents as InboundAttachMessage;
 
@@ -201,7 +212,7 @@ export class DataStores implements IDisposable {
                     ...extractSafePropertiesFromMessage(message),
                     dataStoreId: {
                         value: attachMessage.id,
-                        tag: TelemetryDataTag.PackageData,
+                        tag: TelemetryDataTag.CodeArtifact,
                     },
                 },
             );
@@ -440,7 +451,7 @@ export class DataStores implements IDisposable {
                 eventName: "SignalFluidDataStoreNotFound",
                 fluidDataStoreId: {
                     value: address,
-                    tag: TelemetryDataTag.PackageData,
+                    tag: TelemetryDataTag.CodeArtifact,
                 },
             });
             return;

package/src/garbageCollection.ts

@@ -63,7 +63,7 @@ export const gcBlobPrefix = "__gc";
 // Feature gate key to turn GC on / off.
 const runGCKey = "Fluid.GarbageCollection.RunGC";
 // Feature gate key to turn GC sweep on / off.
-const runSweepKey = "Fluid.GarbageCollection.RunSweep";
+// const runSweepKey = "Fluid.GarbageCollection.RunSweep";
 // Feature gate key to turn GC test mode on / off.
 const gcTestModeKey = "Fluid.GarbageCollection.GCTestMode";
 // Feature gate key to write GC data at the root of the summary tree.
@@ -486,7 +486,7 @@ export class GarbageCollector implements IGarbageCollector {
 
             // Set the Session Expiry only if the flag is enabled or the test option is set.
             if (this.mc.config.getBoolean(runSessionExpiryKey) && this.gcEnabled) {
-                this.sessionExpiryTimeoutMs = defaultSessionExpiryDurationMs;
+                this.sessionExpiryTimeoutMs = this.gcOptions.sessionExpiryTimeoutMs ?? defaultSessionExpiryDurationMs;
             }
         }
 
@@ -503,14 +503,19 @@ export class GarbageCollector implements IGarbageCollector {
                 (timer) => { this.sessionExpiryTimer = timer; },
             );
 
+            // TEMPORARY: Hardcode a default of 2 days which is the value used in the ODSP driver.
+            // This unblocks the Sweep Log (see logSweepEvents function).
+            // This will be removed before sweep is fully implemented.
+            const snapshotCacheExpiryMs = createParams.snapshotCacheExpiryMs ?? 2 * 24 * 60 * 60 * 1000;
+
             /**
              * Sweep timeout is the time after which unreferenced content can be swept.
              * Sweep timeout = session expiry timeout + snapshot cache expiry timeout + one day buffer. The buffer is
              * added to account for any clock skew. We use server timestamps throughout so the skew should be minimal
              * but make it one day to be safe.
              */
-            if (createParams.snapshotCacheExpiryMs !== undefined) {
-                this.sweepTimeoutMs = this.sessionExpiryTimeoutMs + createParams.snapshotCacheExpiryMs + oneDayMs;
+            if (snapshotCacheExpiryMs !== undefined) {
+                this.sweepTimeoutMs = this.sessionExpiryTimeoutMs + snapshotCacheExpiryMs + oneDayMs;
             }
         }
 
@@ -538,9 +543,10 @@ export class GarbageCollector implements IGarbageCollector {
          * 3. Sweep should be enabled for this container (this.sweepEnabled). This can be overridden via runSweep
          *    feature flag.
          */
-        this.shouldRunSweep = this.shouldRunGC
-            && this.sweepTimeoutMs !== undefined
-            && (this.mc.config.getBoolean(runSweepKey) ?? this.sweepEnabled);
+        this.shouldRunSweep = false; // disable while TEMPORARY measure hardcoding snapshotCacheExpiryMs is here
+            // this.shouldRunGC
+            // && this.sweepTimeoutMs !== undefined
+            // && (this.mc.config.getBoolean(runSweepKey) ?? this.sweepEnabled);
 
         this.trackGCState = this.mc.config.getBoolean(trackGCStateKey) === true;
 

package/src/opProperties.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ISequencedDocumentMessage, ISequencedDocumentSystemMessage } from "@fluidframework/protocol-definitions";
+
+export const opSize = (op: ISequencedDocumentMessage): number => {
+    // Some messages may already have string contents,
+    // so stringifying them again will add inaccurate overhead.
+    const content = typeof op.contents === "string" ?
+        op.contents :
+        JSON.stringify(op.contents) ?? "";
+    const data = opHasData(op) ? op.data : "";
+    return content.length + data.length;
+};
+
+const opHasData = (op: ISequencedDocumentMessage): op is ISequencedDocumentSystemMessage =>
+    (op as ISequencedDocumentSystemMessage).data !== undefined;

package/src/packageVersion.ts

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

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,12 +72,36 @@ 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;
     }
 
@@ -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,7 @@ export class RunningSummarizer implements IDisposable {
                 summarySequenceNumber: waitStartResult.value.summaryOp.sequenceNumber,
             });
         }
+        this.initialized = true;
     }
 
     /**

package/src/summarizer.ts

@@ -17,9 +17,6 @@ import {
     IFluidHandle,
     IRequest,
 } from "@fluidframework/core-interfaces";
-import {
-    ISequencedDocumentMessage,
-} from "@fluidframework/protocol-definitions";
 import { ISummaryConfiguration } from "./containerRuntime";
 import { ICancellableSummarizerController } from "./runWhileConnectedCoordinator";
 import { summarizerClientType } from "./summarizerClientElection";
@@ -70,8 +67,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 +272,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 +283,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 +301,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) => {