@fluidframework/container-runtime 2.0.0-dev.4.3.0.159619 → 2.0.0-dev.4.4.0.161516

package/src/gc/gcTelemetry.ts

@@ -0,0 +1,393 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ITelemetryGenericEvent, ITelemetryLogger } from "@fluidframework/common-definitions";
+import { IGarbageCollectionData } from "@fluidframework/runtime-definitions";
+import { packagePathToTelemetryProperty } from "@fluidframework/runtime-utils";
+import {
+	generateStack,
+	MonitoringContext,
+	TelemetryDataTag,
+} from "@fluidframework/telemetry-utils";
+import { ICreateContainerMetadata } from "../summary";
+import {
+	disableSweepLogKey,
+	GCNodeType,
+	UnreferencedState,
+	IGarbageCollectorConfigs,
+	disableTombstoneKey,
+	throwOnTombstoneUsageKey,
+	throwOnTombstoneLoadKey,
+	runSweepKey,
+} from "./gcDefinitions";
+import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";
+
+type NodeUsageType = "Changed" | "Loaded" | "Revived";
+
+/** Properties that are common to IUnreferencedEventProps and INodeUsageProps */
+interface ICommonProps {
+	usageType: NodeUsageType;
+	completedGCRuns: number;
+	isTombstoned: boolean;
+	lastSummaryTime?: number;
+	fromId?: string;
+	viaHandle?: boolean;
+}
+
+/** The event that is logged when unreferenced node is used after a certain time. */
+interface IUnreferencedEventProps extends ICreateContainerMetadata, ICommonProps {
+	state: UnreferencedState;
+	id: string;
+	type: GCNodeType;
+	unrefTime: number;
+	age: number;
+	timeout?: number;
+}
+
+/** Properties passed to nodeUsed function when a node is used. */
+interface INodeUsageProps extends ICommonProps {
+	nodeId: string;
+	currentReferenceTimestampMs: number | undefined;
+	packagePath: readonly string[] | undefined;
+}
+
+/**
+ * Encapsulates the logic that tracks the various telemetry logged by the Garbage Collector. There are 4 types of
+ * telemetry logged:
+ * 1. inactiveObject telemetry - When an inactive node is used - A node that has been unreferenced for inactiveTimeoutMs.
+ * 2. sweepReadyObject telemetry - When a sweep ready node is used - A node that has been unreferenced for sweepTimeoutMs.
+ * 3. Tombstone telemetry - When a tombstoned node is used - A node that that has been marked as tombstone.
+ * 4. Sweep / deleted telemetry - When a node is detected as sweep ready in the sweep phase.
+ * 5. Unknown outbound reference telemetry - When a node is referenced but GC is not explicitly notified of it.
+ */
+export class GCTelemetryTracker {
+	// Keeps track of unreferenced events that are logged for a node. This is used to limit the log generation to one
+	// per event per node.
+	private readonly loggedUnreferencedEvents: Set<string> = new Set();
+	// Queue for unreferenced events that should be logged the next time GC runs.
+	private pendingEventsQueue: IUnreferencedEventProps[] = [];
+
+	constructor(
+		private readonly mc: MonitoringContext,
+		private readonly configs: Pick<
+			IGarbageCollectorConfigs,
+			"inactiveTimeoutMs" | "sweepTimeoutMs"
+		>,
+		private readonly isSummarizerClient: boolean,
+		private readonly gcTombstoneEnforcementAllowed: boolean,
+		private readonly createContainerMetadata: ICreateContainerMetadata,
+		private readonly getNodeType: (nodeId: string) => GCNodeType,
+		private readonly getNodeStateTracker: (
+			nodeId: string,
+		) => UnreferencedStateTracker | undefined,
+		private readonly getNodePackagePath: (
+			nodePath: string,
+		) => Promise<readonly string[] | undefined>,
+	) {}
+
+	/**
+	 * Returns whether an event should be logged for a node that isn't active anymore. Some scenarios where we won't log:
+	 * 1. When a DDS is changed or loaded. The corresponding data store's event will be logged instead.
+	 * 2. An event is logged only once per container instance per event per node.
+	 */
+	private shouldLogNonActiveEvent(
+		nodeId: string,
+		nodeType: GCNodeType,
+		usageType: NodeUsageType,
+		nodeStateTracker: UnreferencedStateTracker,
+		uniqueEventId: string,
+	) {
+		if (nodeStateTracker.state === UnreferencedState.Active) {
+			return false;
+		}
+
+		// For sub data store (DDS) nodes, if they are changed or loaded, its data store will also be changed or loaded,
+		// so skip logging to make the telemetry less noisy.
+		if (nodeType === GCNodeType.SubDataStore && usageType !== "Revived") {
+			return false;
+		}
+		if (nodeType === GCNodeType.Other) {
+			return false;
+		}
+
+		if (this.loggedUnreferencedEvents.has(uniqueEventId)) {
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Called when a node is used. If the node is not active, log an event indicating object is used when its not active.
+	 */
+	public nodeUsed(nodeUsageProps: INodeUsageProps) {
+		// If there is no reference timestamp to work with, no ops have been processed after creation. If so, skip
+		// logging as nothing interesting would have happened worth logging.
+		// If the node is not unreferenced, skip logging.
+		const nodeStateTracker = this.getNodeStateTracker(nodeUsageProps.nodeId);
+		if (!nodeStateTracker || nodeUsageProps.currentReferenceTimestampMs === undefined) {
+			return;
+		}
+
+		// We log these events once per event per node. A unique id is generated by joining node state (inactive / sweep ready),
+		// node's id and usage (loaded / changed / revived).
+		const uniqueEventId = `${nodeStateTracker.state}-${nodeUsageProps.nodeId}-${nodeUsageProps.usageType}`;
+		const nodeType = this.getNodeType(nodeUsageProps.nodeId);
+		if (
+			!this.shouldLogNonActiveEvent(
+				nodeUsageProps.nodeId,
+				nodeType,
+				nodeUsageProps.usageType,
+				nodeStateTracker,
+				uniqueEventId,
+			)
+		) {
+			return;
+		}
+
+		// Add the unique event id so that we don't generate a log for this event again in this session..
+		this.loggedUnreferencedEvents.add(uniqueEventId);
+
+		const state = nodeStateTracker.state;
+		const { usageType, currentReferenceTimestampMs, packagePath, ...propsToLog } =
+			nodeUsageProps;
+		const eventProps: Omit<IUnreferencedEventProps, "state" | "usageType"> = {
+			id: nodeUsageProps.nodeId,
+			type: nodeType,
+			unrefTime: nodeStateTracker.unreferencedTimestampMs,
+			age:
+				nodeUsageProps.currentReferenceTimestampMs -
+				nodeStateTracker.unreferencedTimestampMs,
+			timeout:
+				state === UnreferencedState.Inactive
+					? this.configs.inactiveTimeoutMs
+					: this.configs.sweepTimeoutMs,
+			...propsToLog,
+			...this.createContainerMetadata,
+		};
+
+		// This will log the following events:
+		// GC_Tombstone_DataStore_Revived, GC_Tombstone_SubDataStore_Revived, GC_Tombstone_Blob_Revived
+		if (nodeUsageProps.usageType === "Revived" && nodeUsageProps.isTombstoned) {
+			sendGCUnexpectedUsageEvent(
+				this.mc,
+				{
+					eventName: `GC_Tombstone_${nodeType}_Revived`,
+					category: "generic",
+					url: nodeUsageProps.nodeId,
+					gcTombstoneEnforcementAllowed: this.gcTombstoneEnforcementAllowed,
+				},
+				undefined /* packagePath */,
+			);
+		}
+
+		// For summarizer client, queue the event so it is logged the next time GC runs if the event is still valid.
+		// For non-summarizer client, log the event now since GC won't run on it. This may result in false positives
+		// but it's a good signal nonetheless and we can consume it with a grain of salt.
+		// Inactive errors are usages of Objects that are unreferenced for at least a period of 7 days.
+		// SweepReady errors are usages of Objects that will be deleted by GC Sweep!
+		if (this.isSummarizerClient) {
+			this.pendingEventsQueue.push({
+				...eventProps,
+				usageType: nodeUsageProps.usageType,
+				state,
+			});
+		} else {
+			// For non-summarizer clients, only log "Loaded" type events since these objects may not be loaded in the
+			// summarizer clients if they are based off of user actions (such as scrolling to content for these objects)
+			// Events generated:
+			// InactiveObject_Loaded, SweepReadyObject_Loaded
+			if (nodeUsageProps.usageType === "Loaded") {
+				const event = {
+					eventName: `${state}Object_${nodeUsageProps.usageType}`,
+					pkg: packagePathToTelemetryProperty(nodeUsageProps.packagePath),
+					stack: generateStack(),
+					...eventProps,
+				};
+
+				// Do not log the inactive object x events as error events as they are not the best signal for
+				// detecting something wrong with GC either from the partner or from the runtime itself.
+				if (state === UnreferencedState.Inactive) {
+					this.mc.logger.sendTelemetryEvent(event);
+				} else {
+					this.mc.logger.sendErrorEvent(event);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Log all new references or outbound routes in the current graph that haven't been explicitly notified to GC.
+	 * The principle is that every new reference or outbound route must be notified to GC via the
+	 * addedOutboundReference method. It it hasn't, its a bug and we want to identify these scenarios.
+	 *
+	 * In more simple terms:
+	 * Missing Explicit References = Current References - Previous References - Explicitly Added References;
+	 *
+	 * @param currentGCData - The GC data (reference graph) from the current GC run.
+	 * @param previousGCData - The GC data (reference graph) from the previous GC run.
+	 * @param explicitReferences - New references added explicity between the previous and the current run.
+	 */
+	public logIfMissingExplicitReferences(
+		currentGCData: IGarbageCollectionData,
+		previousGCData: IGarbageCollectionData,
+		explicitReferences: Map<string, string[]>,
+		logger: ITelemetryLogger,
+	) {
+		for (const [nodeId, currentOutboundRoutes] of Object.entries(currentGCData.gcNodes)) {
+			const previousRoutes = previousGCData.gcNodes[nodeId] ?? [];
+			const explicitRoutes = explicitReferences.get(nodeId) ?? [];
+
+			/**
+			 * 1. For routes in the current GC data, routes that were not present in previous GC data and did not have
+			 * explicit references should be added to missing explicit routes list.
+			 * 2. Only include data store and blob routes since GC only works for these two.
+			 * Note: Due to a bug with de-duped blobs, only adding data store routes for now.
+			 * 3. Ignore DDS routes to their parent datastores since those were added implicitly. So, there won't be
+			 * explicit routes to them.
+			 */
+			const missingExplicitRoutes: string[] = [];
+			for (const route of currentOutboundRoutes) {
+				const nodeType = this.getNodeType(route);
+				if (
+					(nodeType === GCNodeType.DataStore || nodeType === GCNodeType.Blob) &&
+					!nodeId.startsWith(route) &&
+					!previousRoutes.includes(route) &&
+					!explicitRoutes.includes(route)
+				) {
+					missingExplicitRoutes.push(route);
+				}
+			}
+
+			if (missingExplicitRoutes.length > 0) {
+				logger.sendErrorEvent({
+					eventName: "gcUnknownOutboundReferences",
+					gcNodeId: nodeId,
+					gcRoutes: JSON.stringify(missingExplicitRoutes),
+				});
+			}
+		}
+	}
+
+	/**
+	 * Log events that are pending in pendingEventsQueue. This is called after GC runs in the summarizer client
+	 * so that the state of an unreferenced node is updated.
+	 */
+	public async logPendingEvents(logger: ITelemetryLogger) {
+		// Events sent come only from the summarizer client. In between summaries, events are pushed to a queue and at
+		// summary time they are then logged.
+		// Events generated:
+		// InactiveObject_Loaded, InactiveObject_Changed, InactiveObject_Revived
+		// SweepReadyObject_Loaded, SweepReadyObject_Changed, SweepReadyObject_Revived
+		for (const eventProps of this.pendingEventsQueue) {
+			const { usageType, state, ...propsToLog } = eventProps;
+			/**
+			 * Revived event is logged only if the node is active. If the node is not active, the reference to it was
+			 * from another unreferenced node and this scenario is not interesting to log.
+			 * Loaded and Changed events are logged only if the node is not active. If the node is active, it was
+			 * revived and a Revived event will be logged for it.
+			 */
+			const nodeStateTracker = this.getNodeStateTracker(eventProps.id);
+			const active =
+				nodeStateTracker === undefined ||
+				nodeStateTracker.state === UnreferencedState.Active;
+			if ((usageType === "Revived") === active) {
+				const pkg = await this.getNodePackagePath(eventProps.id);
+				const fromPkg = eventProps.fromId
+					? await this.getNodePackagePath(eventProps.fromId)
+					: undefined;
+				const event = {
+					...propsToLog,
+					eventName: `${state}Object_${usageType}`,
+					pkg: pkg
+						? { value: pkg.join("/"), tag: TelemetryDataTag.CodeArtifact }
+						: undefined,
+					fromPkg: fromPkg
+						? { value: fromPkg.join("/"), tag: TelemetryDataTag.CodeArtifact }
+						: undefined,
+				};
+
+				if (state === UnreferencedState.Inactive) {
+					logger.sendTelemetryEvent(event);
+				} else {
+					logger.sendErrorEvent(event);
+				}
+			}
+		}
+		this.pendingEventsQueue = [];
+	}
+
+	/**
+	 * For nodes that are ready to sweep, log an event for now. Until we start running sweep which deletes objects,
+	 * this will give us a view into how much deleted content a container has.
+	 */
+	public logSweepEvents(
+		logger: ITelemetryLogger,
+		currentReferenceTimestampMs: number,
+		unreferencedNodesState: Map<string, UnreferencedStateTracker>,
+		completedGCRuns: number,
+		lastSummaryTime?: number,
+	) {
+		if (
+			this.mc.config.getBoolean(disableSweepLogKey) === true ||
+			this.configs.sweepTimeoutMs === undefined
+		) {
+			return;
+		}
+
+		for (const [nodeId, nodeStateTracker] of unreferencedNodesState) {
+			if (nodeStateTracker.state !== UnreferencedState.SweepReady) {
+				return;
+			}
+
+			const nodeType = this.getNodeType(nodeId);
+			if (nodeType !== GCNodeType.DataStore && nodeType !== GCNodeType.Blob) {
+				return;
+			}
+
+			// Log deleted event for each node only once to reduce noise in telemetry.
+			const uniqueEventId = `Deleted-${nodeId}`;
+			if (this.loggedUnreferencedEvents.has(uniqueEventId)) {
+				return;
+			}
+			this.loggedUnreferencedEvents.add(uniqueEventId);
+			logger.sendTelemetryEvent({
+				eventName: "GCObjectDeleted",
+				id: nodeId,
+				type: nodeType,
+				age: currentReferenceTimestampMs - nodeStateTracker.unreferencedTimestampMs,
+				timeout: this.configs.sweepTimeoutMs,
+				completedGCRuns,
+				lastSummaryTime,
+				...this.createContainerMetadata,
+			});
+		}
+	}
+}
+
+/**
+ * Consolidates info / logic for logging when we encounter unexpected usage of GC'd objects. For example, when a
+ * tombstoned or deleted object is loaded.
+ */
+export function sendGCUnexpectedUsageEvent(
+	mc: MonitoringContext,
+	event: ITelemetryGenericEvent & {
+		category: "error" | "generic";
+		gcTombstoneEnforcementAllowed: boolean | undefined;
+	},
+	packagePath: readonly string[] | undefined,
+	error?: unknown,
+) {
+	event.pkg = packagePathToTelemetryProperty(packagePath);
+	event.tombstoneFlags = JSON.stringify({
+		DisableTombstone: mc.config.getBoolean(disableTombstoneKey),
+		ThrowOnTombstoneUsage: mc.config.getBoolean(throwOnTombstoneUsageKey),
+		ThrowOnTombstoneLoad: mc.config.getBoolean(throwOnTombstoneLoadKey),
+	});
+	event.sweepFlags = JSON.stringify({
+		EnableSweepFlag: mc.config.getBoolean(runSweepKey),
+	});
+
+	mc.logger.sendTelemetryEvent(event, error);
+}

package/src/gc/index.ts

@@ -39,7 +39,6 @@ export {
 	cloneGCData,
 	concatGarbageCollectionStates,
 	getGCDataFromSnapshot,
-	sendGCUnexpectedUsageEvent,
 	shouldAllowGcTombstoneEnforcement,
 	shouldAllowGcSweep,
 	trimLeadingAndTrailingSlashes,
@@ -62,4 +61,5 @@ export {
 	closuresMapLocalStorageKey,
 	SweepReadyUsageDetectionHandler,
 } from "./gcSweepReadyUsageDetection";
+export { GCTelemetryTracker, sendGCUnexpectedUsageEvent } from "./gcTelemetry";
 export { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";

package/src/opLifecycle/opGroupingManager.ts

@@ -39,7 +39,6 @@ export class OpGroupingManager {
 			}
 		}
 
-		// Need deserializedContent for back-compat
 		const deserializedContent = {
 			type: OpGroupingManager.groupedBatchOp,
 			contents: batch.content.map<IGroupedMessage>((message) => ({
@@ -56,6 +55,7 @@ export class OpGroupingManager {
 					localOpMetadata: undefined,
 					metadata: undefined,
 					referenceSequenceNumber: batch.content[0].referenceSequenceNumber,
+					// Need deserializedContent for back-compat
 					deserializedContent: deserializedContent as ContainerRuntimeMessage,
 					contents: JSON.stringify(deserializedContent),
 				},

package/src/opLifecycle/outbox.ts

@@ -219,8 +219,8 @@ export class Outbox {
 			return this.params.groupingManager.groupBatch(batch);
 		}
 
-		const compressedBatch = this.params.groupingManager.groupBatch(
-			this.params.compressor.compressBatch(batch),
+		const compressedBatch = this.params.compressor.compressBatch(
+			this.params.groupingManager.groupBatch(batch),
 		);
 
 		if (this.params.splitter.isBatchChunkingEnabled) {

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -27,40 +27,49 @@ export class RemoteMessageProcessor {
 	public process(remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage[] {
 		const result: ISequencedDocumentMessage[] = [];
 
-		// Ungroup before processing chunks
-		for (let ungroupedMessage of this.opGroupingManager.ungroupOp(copy(remoteMessage))) {
-			ungroupedMessage = this.opDecompressor.processMessage(ungroupedMessage).message;
-			unpackRuntimeMessage(ungroupedMessage);
-
-			const chunkProcessingResult = this.opSplitter.processRemoteMessage(ungroupedMessage);
-			ungroupedMessage = chunkProcessingResult.message;
-			if (chunkProcessingResult.state !== "Processed") {
-				// If the message is not chunked or if the splitter is still rebuilding the original message,
-				// there is no need to continue processing
-				result.push(ungroupedMessage);
-				continue;
-			}
-
-			// Ungroup the chunked message before decompressing
-			for (let ungroupedMessageAfterChunking of this.opGroupingManager.ungroupOp(
-				ungroupedMessage,
-			)) {
-				const decompressionAfterChunking = this.opDecompressor.processMessage(
-					ungroupedMessageAfterChunking,
-				);
-				ungroupedMessageAfterChunking = decompressionAfterChunking.message;
-				if (decompressionAfterChunking.state === "Skipped") {
-					// After chunking, if the original message was not compressed,
+		// Ungroup before and after decompression for back-compat (cleanup tracked by AB#4371)
+		for (const ungroupedMessage of this.opGroupingManager.ungroupOp(copy(remoteMessage))) {
+			const message = this.opDecompressor.processMessage(ungroupedMessage).message;
+
+			for (let ungroupedMessage2 of this.opGroupingManager.ungroupOp(message)) {
+				unpackRuntimeMessage(ungroupedMessage2);
+
+				const chunkProcessingResult =
+					this.opSplitter.processRemoteMessage(ungroupedMessage2);
+				ungroupedMessage2 = chunkProcessingResult.message;
+				if (chunkProcessingResult.state !== "Processed") {
+					// If the message is not chunked or if the splitter is still rebuilding the original message,
 					// there is no need to continue processing
-					result.push(ungroupedMessageAfterChunking);
+					result.push(ungroupedMessage2);
 					continue;
 				}
 
-				// The message needs to be unpacked after chunking + decompression
-				unpack(ungroupedMessageAfterChunking);
-				result.push(ungroupedMessageAfterChunking);
+				// Ungroup before and after decompression for back-compat (cleanup tracked by AB#4371)
+				for (const ungroupedMessageAfterChunking of this.opGroupingManager.ungroupOp(
+					ungroupedMessage2,
+				)) {
+					const decompressionAfterChunking = this.opDecompressor.processMessage(
+						ungroupedMessageAfterChunking,
+					);
+
+					for (const ungroupedMessageAfterChunking2 of this.opGroupingManager.ungroupOp(
+						decompressionAfterChunking.message,
+					)) {
+						if (decompressionAfterChunking.state === "Skipped") {
+							// After chunking, if the original message was not compressed,
+							// there is no need to continue processing
+							result.push(ungroupedMessageAfterChunking2);
+							continue;
+						}
+
+						// The message needs to be unpacked after chunking + decompression
+						unpack(ungroupedMessageAfterChunking2);
+						result.push(ungroupedMessageAfterChunking2);
+					}
+				}
 			}
 		}
+
 		return result;
 	}
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-dev.4.3.0.159619";
+export const pkgVersion = "2.0.0-dev.4.4.0.161516";

package/src/summary/summarizer.ts

@@ -25,6 +25,7 @@ import { RunningSummarizer } from "./runningSummarizer";
 import {
 	IConnectableRuntime,
 	ISummarizer,
+	ISummarizeHeuristicData,
 	ISummarizerInternalsProvider,
 	ISummarizerRuntime,
 	ISummarizingWarning,
@@ -215,6 +216,8 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 		return stopReason === "parentNotConnected";
 	}
 
+	private _heuristicData: ISummarizeHeuristicData | undefined;
+
 	/**
 	 * Put the summarizer in a started state, including creating and initializing the RunningSummarizer.
 	 * The start request can come either from the SummaryManager (in the auto-summarize case) or from the user
@@ -252,17 +255,22 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 			throw new UsageError("clientId should be defined if connected.");
 		}
 
+		this._heuristicData = new SummarizeHeuristicData(
+			this.runtime.deltaManager.lastSequenceNumber,
+			{
+				/** summary attempt baseline for heuristics */
+				refSequenceNumber: this.runtime.deltaManager.initialSequenceNumber,
+				summaryTime: Date.now(),
+			} as const,
+		);
+
 		const runningSummarizer = await RunningSummarizer.start(
 			this.logger,
 			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),
+			this._heuristicData,
 			this.summaryCollection,
 			runCoordinator /* cancellationToken */,
 			(reason) => runCoordinator.stop(reason) /* stopSummarizerCallback */,
@@ -361,4 +369,8 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 		}
 		return this.runningSummarizer.enqueueSummarize(...args);
 	};
+
+	public recordSummaryAttempt?(summaryRefSeqNum?: number) {
+		this._heuristicData?.recordAttempt(summaryRefSeqNum);
+	}
 }

package/src/summary/summarizerHeuristics.ts

@@ -27,32 +27,31 @@ export class SummarizeHeuristicData implements ISummarizeHeuristicData {
 	}
 
 	public get opsSinceLastSummary(): number {
-		return this.numSystemOpsBefore + this.numNonSystemOpsBefore;
+		return this.numNonRuntimeOpsBefore + this.numRuntimeOpsBefore;
 	}
 
-	public numNonRuntimeOps: number = 0;
-	public totalOpsSize: number = 0;
 	public hasMissingOpData: boolean = false;
 
+	public totalOpsSize: number = 0;
 	/**
 	 * 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;
 
+	public numNonRuntimeOps: number = 0;
 	/**
-	 * Number of system ops at beginning of attempting to summarize.
-	 * Is used to adjust numSystemOps appropriately after successful summarization.
+	 * Number of non-runtime ops at beginning of attempting to summarize.
+	 * Is used to adjust numNonRuntimeOps appropriately after successful summarization.
 	 */
-	private numSystemOpsBefore: number = 0;
+	private numNonRuntimeOpsBefore: 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.
+	 * Number of runtime ops at beginning of attempting to summarize.
+	 * Is used to adjust numRuntimeOps appropriately after successful summarization.
 	 */
-	private numNonSystemOpsBefore: number = 0;
+	private numRuntimeOpsBefore: number = 0;
 
 	constructor(
 		public lastOpSequenceNumber: number,
@@ -74,19 +73,19 @@ export class SummarizeHeuristicData implements ISummarizeHeuristicData {
 			summaryTime: Date.now(),
 		};
 
-		this.numSystemOpsBefore = this.numNonRuntimeOps;
-		this.numNonSystemOpsBefore = this.numRuntimeOps;
+		this.numNonRuntimeOpsBefore = this.numNonRuntimeOps;
+		this.numRuntimeOpsBefore = this.numRuntimeOps;
 		this.totalOpsSizeBefore = this.totalOpsSize;
 	}
 
 	public markLastAttemptAsSuccessful() {
 		this._lastSuccessfulSummary = { ...this.lastAttempt };
 
-		this.numNonRuntimeOps -= this.numSystemOpsBefore;
-		this.numSystemOpsBefore = 0;
+		this.numNonRuntimeOps -= this.numNonRuntimeOpsBefore;
+		this.numNonRuntimeOpsBefore = 0;
 
-		this.numRuntimeOps -= this.numNonSystemOpsBefore;
-		this.numNonSystemOpsBefore = 0;
+		this.numRuntimeOps -= this.numRuntimeOpsBefore;
+		this.numRuntimeOpsBefore = 0;
 
 		this.totalOpsSize -= this.totalOpsSizeBefore;
 		this.totalOpsSizeBefore = 0;

package/src/summary/summarizerTypes.ts

@@ -489,6 +489,8 @@ type SummaryGeneratorOptionalTelemetryProperties =
 	| "opsSizesSinceLastSummary"
 	/** Delta between the number of non-runtime ops since the last summary */
 	| "nonRuntimeOpsSinceLastSummary"
+	/** Delta between the number of runtime ops since the last summary */
+	| "runtimeOpsSinceLastSummary"
 	/** Wether or not this instance contains adjusted metrics due to missing op data */
 	| "hasMissingOpData"
 	/** Time it took to generate the summary tree and stats. */