@fluidframework/container-runtime 2.0.0-internal.4.2.1 → 2.0.0-internal.4.4.0

package/src/gc/garbageCollection.ts

@@ -4,7 +4,7 @@
  */
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { assert, LazyPromise, Timer } from "@fluidframework/common-utils";
+import { LazyPromise, Timer } from "@fluidframework/common-utils";
 import { ClientSessionExpiredError, DataProcessingError } from "@fluidframework/container-utils";
 import { IRequestHeader } from "@fluidframework/core-interfaces";
 import {
@@ -14,21 +14,18 @@ import {
 	ISummarizeResult,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions";
-import { packagePathToTelemetryProperty, ReadAndParseBlob } from "@fluidframework/runtime-utils";
+import { ReadAndParseBlob } from "@fluidframework/runtime-utils";
 import {
 	ChildLogger,
-	generateStack,
 	loggerToMonitoringContext,
 	MonitoringContext,
 	PerformanceEvent,
-	TelemetryDataTag,
 } from "@fluidframework/telemetry-utils";
 
 import { RuntimeHeaders } from "../containerRuntime";
-import { ICreateContainerMetadata, RefreshSummaryResult } from "../summary";
+import { RefreshSummaryResult } from "../summary";
 import { generateGCConfigs } from "./gcConfigs";
 import {
-	disableSweepLogKey,
 	GCNodeType,
 	IGarbageCollector,
 	IGarbageCollectorCreateParams,
@@ -39,31 +36,12 @@ import {
 	IGCMetadata,
 	IGarbageCollectorConfigs,
 } from "./gcDefinitions";
-import {
-	cloneGCData,
-	concatGarbageCollectionData,
-	getGCDataFromSnapshot,
-	sendGCUnexpectedUsageEvent,
-} from "./gcHelpers";
+import { cloneGCData, concatGarbageCollectionData, getGCDataFromSnapshot } from "./gcHelpers";
 import { runGarbageCollection } from "./gcReferenceGraphAlgorithm";
 import { IGarbageCollectionSnapshotData, IGarbageCollectionState } from "./gcSummaryDefinitions";
 import { GCSummaryStateTracker } from "./gcSummaryStateTracker";
 import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";
-
-/** The event that is logged when unreferenced node is used after a certain time. */
-interface IUnreferencedEventProps {
-	usageType: "Changed" | "Loaded" | "Revived";
-	state: UnreferencedState;
-	id: string;
-	type: GCNodeType;
-	unrefTime: number;
-	age: number;
-	completedGCRuns: number;
-	fromId?: string;
-	timeout?: number;
-	lastSummaryTime?: number;
-	viaHandle?: boolean;
-}
+import { GCTelemetryTracker } from "./gcTelemetry";
 
 /**
  * The garbage collector for the container runtime. It consolidates the garbage collection functionality and maintains
@@ -121,20 +99,14 @@ export class GarbageCollector implements IGarbageCollector {
 	// The Timer responsible for closing the container when the session has expired
 	private sessionExpiryTimer: Timer | undefined;
 
-	// 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[] = [];
-
 	// The number of times GC has successfully completed on this instance of GarbageCollector.
 	private completedRuns = 0;
 
 	private readonly runtime: IGarbageCollectionRuntime;
-	private readonly createContainerMetadata: ICreateContainerMetadata;
 	private readonly isSummarizerClient: boolean;
 
 	private readonly summaryStateTracker: GCSummaryStateTracker;
+	private readonly telemetryTracker: GCTelemetryTracker;
 
 	/** For a given node path, returns the node's package path. */
 	private readonly getNodePackagePath: (
@@ -149,10 +121,14 @@ export class GarbageCollector implements IGarbageCollector {
 		return this.summaryStateTracker.doesSummaryStateNeedReset;
 	}
 
+	/** Returns the count of data stores whose GC state updated since the last summary. */
+	public get updatedDSCountSinceLastSummary(): number {
+		return this.summaryStateTracker.updatedDSCountSinceLastSummary;
+	}
+
 	protected constructor(createParams: IGarbageCollectorCreateParams) {
 		this.runtime = createParams.runtime;
 		this.isSummarizerClient = createParams.isSummarizerClient;
-		this.createContainerMetadata = createParams.createContainerMetadata;
 		this.getNodePackagePath = createParams.getNodePackagePath;
 		this.getLastSummaryTimestampMs = createParams.getLastSummaryTimestampMs;
 		this.activeConnection = createParams.activeConnection;
@@ -189,6 +165,17 @@ export class GarbageCollector implements IGarbageCollector {
 			baseSnapshot?.trees[gcTreeKey] !== undefined /* wasGCRunInBaseSnapshot */,
 		);
 
+		this.telemetryTracker = new GCTelemetryTracker(
+			this.mc,
+			this.configs,
+			this.isSummarizerClient,
+			this.runtime.gcTombstoneEnforcementAllowed,
+			createParams.createContainerMetadata,
+			(nodeId: string) => this.runtime.getNodeType(nodeId),
+			(nodeId: string) => this.unreferencedNodesState.get(nodeId),
+			this.getNodePackagePath,
+		);
+
 		// Get the GC data from the base snapshot. Use LazyPromise because we only want to do this once since it
 		// it involves fetching blobs from storage which is expensive.
 		this.baseSnapshotDataP = new LazyPromise<IGarbageCollectionSnapshotData | undefined>(
@@ -215,10 +202,7 @@ export class GarbageCollector implements IGarbageCollector {
 					// in the snapshot cannot be interpreted correctly. Set everything to undefined except for
 					// deletedNodes because irrespective of GC versions, these nodes have been deleted and cannot be
 					// brought back. The deletedNodes info is needed to identify when these nodes are used.
-					if (
-						this.configs.gcVersionInBaseSnapshot !==
-						this.summaryStateTracker.currentGCVersion
-					) {
+					if (this.configs.gcVersionInEffect !== this.configs.gcVersionInBaseSnapshot) {
 						return {
 							gcState: undefined,
 							tombstones: undefined,
@@ -447,6 +431,14 @@ export class GarbageCollector implements IGarbageCollector {
 		}
 	}
 
+	/**
+	 * Returns a the GC details generated from the base summary. This is used to initialize the GC state of the nodes
+	 * in the container.
+	 */
+	public async getBaseGCDetails(): Promise<IGarbageCollectionDetailsBase> {
+		return this.baseGCDetailsP;
+	}
+
 	/**
 	 * Runs garbage collection and updates the reference / used state of the nodes in the container.
 	 * @returns stats of the GC run or undefined if GC did not run.
@@ -500,80 +492,297 @@ export class GarbageCollector implements IGarbageCollector {
 			logger,
 			{ eventName: "GarbageCollection" },
 			async (event) => {
-				await this.runPreGCSteps();
-
-				// Get the runtime's GC data and run GC on the reference graph in it.
-				const gcData = await this.runtime.getGCData(fullGC);
-				const gcResult = runGarbageCollection(gcData.gcNodes, ["/"]);
-
-				const gcStats = await this.runPostGCSteps(
-					gcData,
-					gcResult,
-					logger,
-					currentReferenceTimestampMs,
-				);
+				/** Pre-GC steps */
+				// Ensure that state has been initialized from the base snapshot data.
+				await this.initializeGCStateFromBaseSnapshotP;
+				// Let the runtime update its pending state before GC runs.
+				await this.runtime.updateStateBeforeGC();
+
+				/** GC step */
+				const gcStats = await this.runGC(fullGC, currentReferenceTimestampMs, logger);
 				event.end({ ...gcStats, timestamp: currentReferenceTimestampMs });
+
+				/** Post-GC steps */
+				// Log pending unreferenced events such as a node being used after inactive. This is done after GC runs and
+				// updates its state so that we don't send false positives based on intermediate state. For example, we may get
+				// reference to an unreferenced node from another unreferenced node which means the node wasn't revived.
+				await this.telemetryTracker.logPendingEvents(logger);
+				// Update the state of summary state tracker from this run's stats.
+				this.summaryStateTracker.updateStateFromGCRunStats(gcStats);
+				this.newReferencesSinceLastRun.clear();
 				this.completedRuns++;
+
 				return gcStats;
 			},
 			{ end: true, cancel: "error" },
 		);
 	}
 
-	private async runPreGCSteps() {
-		// Ensure that state has been initialized from the base snapshot data.
-		await this.initializeGCStateFromBaseSnapshotP;
-		// Let the runtime update its pending state before GC runs.
-		await this.runtime.updateStateBeforeGC();
-	}
-
-	private async runPostGCSteps(
-		gcData: IGarbageCollectionData,
-		gcResult: IGCResult,
-		logger: ITelemetryLogger,
+	/**
+	 * Runs garbage collection. It does the following:
+	 * 1. It generates / analyzes the runtime's reference graph.
+	 * 2. Generates stats for the GC run based on previous / current GC state.
+	 * 3. Runs Mark phase.
+	 * 4. Runs Sweep phase.
+	 */
+	private async runGC(
+		fullGC: boolean,
 		currentReferenceTimestampMs: number,
+		logger: ITelemetryLogger,
 	): Promise<IGCStats> {
-		// Generate statistics from the current run. This is done before updating the current state because it
-		// generates some of its data based on previous state of the system.
+		// 1. Generate / analyze the runtime's reference graph.
+		// Get the reference graph (gcData) and run GC algorithm to get referenced / unreferenced nodes.
+		const gcData = await this.runtime.getGCData(fullGC);
+		const gcResult = runGarbageCollection(gcData.gcNodes, ["/"]);
+		// Get all referenced nodes - References in this run + references between the previous and current runs.
+		const allReferencedNodeIds =
+			this.findAllNodesReferencedBetweenGCs(gcData, this.gcDataFromLastRun, logger) ??
+			gcResult.referencedNodeIds;
+
+		// 2. Generate stats based on the previous / current GC state.
+		// Must happen before running Mark / Sweep phase because previous GC state will be updated in these stages.
 		const gcStats = this.generateStats(gcResult);
 
-		// Update the current mark state and update the runtime of all used routes or ids that used as per the GC run.
-		const sweepReadyNodes = this.updateMarkPhase(
-			gcData,
+		// 3. Run the Mark phase.
+		// It will mark nodes as referenced / unreferenced and return a list of node ids that are ready to be swept.
+		const sweepReadyNodeIds = this.runMarkPhase(
+			gcResult,
+			allReferencedNodeIds,
+			currentReferenceTimestampMs,
+		);
+
+		// 4. Run the Sweep phase.
+		// It will delete sweep ready nodes and return a list of deleted node ids.
+		const deletedNodeIds = this.runSweepPhase(
 			gcResult,
+			sweepReadyNodeIds,
 			currentReferenceTimestampMs,
 			logger,
 		);
+
+		this.gcDataFromLastRun = cloneGCData(
+			gcData,
+			(id: string) => deletedNodeIds.includes(id) /* filter out deleted nodes */,
+		);
+		return gcStats;
+	}
+
+	/**
+	 * Runs the GC Mark phase. It does the following:
+	 * 1. Marks all referenced nodes in this run by clearing tracking for them.
+	 * 2. Marks unreferenced nodes in this run by starting tracking for them.
+	 * 3. Calls the runtime to update nodes that were marked referenced.
+	 *
+	 * @param gcResult - The result of the GC run on the gcData.
+	 * @param allReferencedNodeIds - Nodes referenced in this GC run + referenced between previous and current GC run.
+	 * @param currentReferenceTimestampMs - The timestamp to be used for unreferenced nodes' timestamp.
+	 * @returns - A list of sweep ready nodes, i.e., nodes that ready to be deleted.
+	 */
+	private runMarkPhase(
+		gcResult: IGCResult,
+		allReferencedNodeIds: string[],
+		currentReferenceTimestampMs: number,
+	): string[] {
+		// 1. Marks all referenced nodes by clearing their unreferenced tracker, if any.
+		for (const nodeId of allReferencedNodeIds) {
+			const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
+			if (nodeStateTracker !== undefined) {
+				// Stop tracking so as to clear out any running timers.
+				nodeStateTracker.stopTracking();
+				// Delete the node as we don't need to track it any more.
+				this.unreferencedNodesState.delete(nodeId);
+			}
+		}
+
+		// 2. Mark unreferenced nodes in this run by starting unreferenced tracking for them.
+		const sweepReadyNodeIds: string[] = [];
+		for (const nodeId of gcResult.deletedNodeIds) {
+			const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
+			if (nodeStateTracker === undefined) {
+				this.unreferencedNodesState.set(
+					nodeId,
+					new UnreferencedStateTracker(
+						currentReferenceTimestampMs,
+						this.configs.inactiveTimeoutMs,
+						currentReferenceTimestampMs,
+						this.configs.sweepTimeoutMs,
+					),
+				);
+			} else {
+				// If a node was already unreferenced, update its tracking information. Since the current reference time
+				// is from the ops seen, this will ensure that we keep updating unreferenced state as time moves forward.
+				nodeStateTracker.updateTracking(currentReferenceTimestampMs);
+
+				// If a node is sweep ready, store it so it can be returned.
+				if (nodeStateTracker.state === UnreferencedState.SweepReady) {
+					sweepReadyNodeIds.push(nodeId);
+				}
+			}
+		}
+
+		// 3. Call the runtime to update referenced nodes in this run.
 		this.runtime.updateUsedRoutes(gcResult.referencedNodeIds);
 
-		// Log events for objects that are ready to be deleted by sweep. When we have sweep enabled, we will
-		// delete these objects here instead.
-		this.logSweepEvents(logger, currentReferenceTimestampMs);
+		return sweepReadyNodeIds;
+	}
 
-		let updatedGCData: IGarbageCollectionData = gcData;
+	/**
+	 * Runs the GC Sweep phase. It does the following:
+	 * 1. Calls the runtime to delete nodes that are sweep ready.
+	 * 2. Clears tracking for deleted nodes.
+	 *
+	 * @param gcResult - The result of the GC run on the gcData.
+	 * @param sweepReadyNodes - List of nodes that are sweep ready.
+	 * @param currentReferenceTimestampMs - The timestamp to be used for unreferenced nodes' timestamp.
+	 * @param logger - The logger to be used to log any telemetry.
+	 * @returns - A list of nodes that have been deleted.
+	 */
+	private runSweepPhase(
+		gcResult: IGCResult,
+		sweepReadyNodes: string[],
+		currentReferenceTimestampMs: number,
+		logger: ITelemetryLogger,
+	): string[] {
+		// Log events for objects that are ready to be deleted by sweep. This will give us data on sweep when
+		// its not enabled.
+		this.telemetryTracker.logSweepEvents(
+			logger,
+			currentReferenceTimestampMs,
+			this.unreferencedNodesState,
+			this.completedRuns,
+			this.getLastSummaryTimestampMs(),
+		);
 
-		if (this.configs.shouldRunSweep) {
-			updatedGCData = this.runSweepPhase(sweepReadyNodes, gcData);
-		} else if (this.configs.testMode) {
-			// If we are running in GC test mode, delete objects for unused routes. This enables testing scenarios
-			// involving access to deleted data.
+		/**
+		 * Currently, there are 3 modes for sweep:
+		 * Test mode - Unreferenced nodes are immediately deleted without waiting for them to be sweep ready.
+		 * Tombstone mode - Sweep ready modes are marked as tombstones instead of being deleted.
+		 * Sweep mode - Sweep ready modes are deleted.
+		 *
+		 * These modes serve as staging for applications that want to enable sweep by providing an incremental
+		 * way to test and validate sweep works as expected.
+		 */
+		if (this.configs.testMode) {
+			// If we are running in GC test mode, unreferenced nodes (gcResult.deletedNodeIds) are deleted.
 			this.runtime.updateUnusedRoutes(gcResult.deletedNodeIds);
-		} else if (this.configs.tombstoneMode) {
+			return [];
+		}
+
+		if (this.configs.tombstoneMode) {
 			this.tombstones = sweepReadyNodes;
 			// If we are running in GC tombstone mode, update tombstoned routes. This enables testing scenarios
 			// involving access to "deleted" data without actually deleting the data from summaries.
-			// Note: we will not tombstone in test mode.
 			this.runtime.updateTombstonedRoutes(this.tombstones);
+			return [];
 		}
 
-		this.gcDataFromLastRun = cloneGCData(updatedGCData);
+		if (!this.configs.shouldRunSweep) {
+			return [];
+		}
 
-		// Log pending unreferenced events such as a node being used after inactive. This is done after GC runs and
-		// updates its state so that we don't send false positives based on intermediate state. For example, we may get
-		// reference to an unreferenced node from another unreferenced node which means the node wasn't revived.
-		await this.logUnreferencedEvents(logger);
+		// 1. Call the runtime to delete sweep ready nodes. The runtime returns a list of nodes it deleted.
+		// TODO: GC:Validation - validate that removed routes are not double delete and that the child routes of
+		// removed routes are deleted as well.
+		const deletedNodeIds = this.runtime.deleteSweepReadyNodes(sweepReadyNodes);
 
-		return gcStats;
+		// 2. Clear unreferenced state tracking for deleted nodes.
+		for (const nodeId of deletedNodeIds) {
+			const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
+			// TODO: GC:Validation - assert that the nodeStateTracker is defined
+			if (nodeStateTracker !== undefined) {
+				// Stop tracking so as to clear out any running timers.
+				nodeStateTracker.stopTracking();
+				// Delete the node as we don't need to track it any more.
+				this.unreferencedNodesState.delete(nodeId);
+			}
+			// TODO: GC:Validation - assert that the deleted node is not a duplicate
+			this.deletedNodes.add(nodeId);
+		}
+		return deletedNodeIds;
+	}
+
+	/**
+	 * Since GC runs periodically, the GC data that is generated only tells us the state of the world at that point in
+	 * time. There can be nodes that were referenced in between two runs and their unreferenced state needs to be
+	 * updated. For example, in the following scenarios not updating the unreferenced timestamp can lead to deletion of
+	 * these objects while there can be in-memory referenced to it:
+	 * 1. A node transitions from `unreferenced -> referenced -> unreferenced` between two runs. When the reference is
+	 * added, the object may have been accessed and in-memory reference to it added.
+	 * 2. A reference is added from one unreferenced node to one or more unreferenced nodes. Even though the node[s] were
+	 * unreferenced, they could have been accessed and in-memory reference to them added.
+	 *
+	 * This function identifies nodes that were referenced since the last run.
+	 * If these nodes are currently unreferenced, they will be assigned new unreferenced state by the current run.
+	 *
+	 * @returns - a list of all nodes referenced from the last local summary until now.
+	 */
+	private findAllNodesReferencedBetweenGCs(
+		currentGCData: IGarbageCollectionData,
+		previousGCData: IGarbageCollectionData | undefined,
+		logger: ITelemetryLogger,
+	): string[] | undefined {
+		// If we haven't run GC before there is nothing to do.
+		// No previousGCData, means nothing is unreferenced, and there are no reference state trackers to clear
+		if (previousGCData === undefined) {
+			return undefined;
+		}
+
+		/**
+		 * If there are references that were not explicitly notified to GC, log an error because this should never happen.
+		 * If it does, this may result in the unreferenced timestamps of these nodes not updated when they were referenced.
+		 */
+		this.telemetryTracker.logIfMissingExplicitReferences(
+			currentGCData,
+			previousGCData,
+			this.newReferencesSinceLastRun,
+			logger,
+		);
+
+		// No references were added since the last run so we don't have to update reference states of any unreferenced
+		// nodes. There is no in between state at this point.
+		if (this.newReferencesSinceLastRun.size === 0) {
+			return undefined;
+		}
+
+		/**
+		 * Generate a super set of the GC data that contains the nodes and edges from last run, plus any new node and
+		 * edges that have been added since then. To do this, combine the GC data from the last run and the current
+		 * run, and then add the references since last run.
+		 *
+		 * Note on why we need to combine the data from previous run, current run and all references in between -
+		 * 1. We need data from last run because some of its references may have been deleted since then. If those
+		 * references added new outbound references before they were deleted, we need to detect them.
+		 *
+		 * 2. We need new outbound references since last run because some of them may have been deleted later. If those
+		 * references added new outbound references before they were deleted, we need to detect them.
+		 *
+		 * 3. We need data from the current run because currently we may not detect when DDSes are referenced:
+		 * - We don't require DDSes handles to be stored in a referenced DDS.
+		 * - A new data store may have "root" DDSes already created and we don't detect them today.
+		 */
+		const gcDataSuperSet = concatGarbageCollectionData(previousGCData, currentGCData);
+		const newOutboundRoutesSinceLastRun: string[] = [];
+		this.newReferencesSinceLastRun.forEach((outboundRoutes: string[], sourceNodeId: string) => {
+			if (gcDataSuperSet.gcNodes[sourceNodeId] === undefined) {
+				gcDataSuperSet.gcNodes[sourceNodeId] = outboundRoutes;
+			} else {
+				gcDataSuperSet.gcNodes[sourceNodeId].push(...outboundRoutes);
+			}
+			newOutboundRoutesSinceLastRun.push(...outboundRoutes);
+		});
+
+		/**
+		 * Run GC on the above reference graph starting with root and all new outbound routes. This will generate a
+		 * list of all nodes that could have been referenced since the last run. If any of these nodes are unreferenced,
+		 * unreferenced, stop tracking them and remove from unreferenced list.
+		 * Note that some of these nodes may be unreferenced now and if so, the current run will mark them as
+		 * unreferenced and add unreferenced state.
+		 */
+		const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, [
+			"/",
+			...newOutboundRoutesSinceLastRun,
+		]);
+		return gcResult.referencedNodeIds;
 	}
 
 	/**
@@ -611,10 +820,10 @@ export class GarbageCollector implements IGarbageCollector {
 	public getMetadata(): IGCMetadata {
 		return {
 			/**
-			 * If GC is enabled, the GC data is written using the current GC version and that is the gcFeature that goes
+			 * If GC is enabled, the GC data is written using the GC version in effect and that is the gcFeature that goes
 			 * into the metadata blob. If GC is disabled, the gcFeature is 0.
 			 */
-			gcFeature: this.configs.gcEnabled ? this.summaryStateTracker.currentGCVersion : 0,
+			gcFeature: this.configs.gcEnabled ? this.configs.gcVersionInEffect : 0,
 			gcFeatureMatrix: this.configs.persistedGcFeatureMatrix,
 			sessionExpiryTimeoutMs: this.configs.sessionExpiryTimeoutMs,
 			sweepEnabled: false, // DEPRECATED - to be removed
@@ -622,14 +831,6 @@ export class GarbageCollector implements IGarbageCollector {
 		};
 	}
 
-	/**
-	 * Returns a the GC details generated from the base summary. This is used to initialize the GC state of the nodes
-	 * in the container.
-	 */
-	public async getBaseGCDetails(): Promise<IGarbageCollectionDetailsBase> {
-		return this.baseGCDetailsP;
-	}
-
 	/**
 	 * Called to refresh the latest summary state. This happens when either a pending summary is acked or a snapshot
 	 * is downloaded and should be used to update the state.
@@ -686,18 +887,17 @@ export class GarbageCollector implements IGarbageCollector {
 			return;
 		}
 
-		const nodeStateTracker = this.unreferencedNodesState.get(nodePath);
-		if (nodeStateTracker && nodeStateTracker.state !== UnreferencedState.Active) {
-			this.inactiveNodeUsed(
-				reason,
-				nodePath,
-				nodeStateTracker,
-				undefined /* fromNodeId */,
-				packagePath,
-				timestampMs,
-				requestHeaders,
-			);
-		}
+		this.telemetryTracker.nodeUsed({
+			id: nodePath,
+			usageType: reason,
+			currentReferenceTimestampMs:
+				timestampMs ?? this.runtime.getCurrentReferenceTimestampMs(),
+			packagePath,
+			completedGCRuns: this.completedRuns,
+			isTombstoned: this.tombstones.includes(nodePath),
+			lastSummaryTime: this.getLastSummaryTimestampMs(),
+			viaHandle: requestHeaders?.[RuntimeHeaders.viaHandle],
+		});
 	}
 
 	/**
@@ -716,33 +916,16 @@ export class GarbageCollector implements IGarbageCollector {
 		outboundRoutes.push(toNodePath);
 		this.newReferencesSinceLastRun.set(fromNodePath, outboundRoutes);
 
-		const nodeStateTracker = this.unreferencedNodesState.get(toNodePath);
-		if (nodeStateTracker && nodeStateTracker.state !== UnreferencedState.Active) {
-			this.inactiveNodeUsed("Revived", toNodePath, nodeStateTracker, fromNodePath);
-		}
-
-		if (this.tombstones.includes(toNodePath)) {
-			const nodeType = this.runtime.getNodeType(toNodePath);
-
-			let eventName = "GC_Tombstone_SubDatastore_Revived";
-			if (nodeType === GCNodeType.DataStore) {
-				eventName = "GC_Tombstone_Datastore_Revived";
-			} else if (nodeType === GCNodeType.Blob) {
-				eventName = "GC_Tombstone_Blob_Revived";
-			}
-
-			sendGCUnexpectedUsageEvent(
-				this.mc,
-				{
-					eventName,
-					category: "generic",
-					url: toNodePath,
-					nodeType,
-					gcTombstoneEnforcementAllowed: this.runtime.gcTombstoneEnforcementAllowed,
-				},
-				undefined /* packagePath */,
-			);
-		}
+		this.telemetryTracker.nodeUsed({
+			id: toNodePath,
+			usageType: "Revived",
+			currentReferenceTimestampMs: this.runtime.getCurrentReferenceTimestampMs(),
+			packagePath: undefined,
+			completedGCRuns: this.completedRuns,
+			isTombstoned: this.tombstones.includes(toNodePath),
+			lastSummaryTime: this.getLastSummaryTimestampMs(),
+			fromId: fromNodePath,
+		});
 	}
 
 	/**
@@ -758,267 +941,6 @@ export class GarbageCollector implements IGarbageCollector {
 		this.sessionExpiryTimer = undefined;
 	}
 
-	/**
-	 * Updates the state of the system as per the current GC run. It does the following:
-	 * 1. Sets up the current GC state as per the gcData.
-	 * 2. Starts tracking for nodes that have become unreferenced in this run.
-	 * 3. Clears tracking for nodes that were unreferenced but became referenced in this run.
-	 * @param gcData - The data representing the reference graph on which GC is run.
-	 * @param gcResult - The result of the GC run on the gcData.
-	 * @param currentReferenceTimestampMs - The timestamp to be used for unreferenced nodes' timestamp.
-	 * @returns - A list of sweep ready nodes. (Nodes ready to be deleted)
-	 */
-	private updateMarkPhase(
-		gcData: IGarbageCollectionData,
-		gcResult: IGCResult,
-		currentReferenceTimestampMs: number,
-		logger: ITelemetryLogger,
-	) {
-		// Get references from the current GC run + references between previous and current run and then update each
-		// node's state
-		const allNodesReferencedBetweenGCs =
-			this.findAllNodesReferencedBetweenGCs(gcData, this.gcDataFromLastRun, logger) ??
-			gcResult.referencedNodeIds;
-		this.newReferencesSinceLastRun.clear();
-
-		// Iterate through the referenced nodes and stop tracking if they were unreferenced before.
-		for (const nodeId of allNodesReferencedBetweenGCs) {
-			const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
-			if (nodeStateTracker !== undefined) {
-				// Stop tracking so as to clear out any running timers.
-				nodeStateTracker.stopTracking();
-				// Delete the node as we don't need to track it any more.
-				this.unreferencedNodesState.delete(nodeId);
-			}
-		}
-
-		/**
-		 * If a node became unreferenced in this run, start tracking it.
-		 * If a node was already unreferenced, update its tracking information. Since the current reference time is
-		 * from the ops seen, this will ensure that we keep updating the unreferenced state as time moves forward.
-		 *
-		 * If a node is sweep ready, store and then return it.
-		 */
-		const sweepReadyNodes: string[] = [];
-		for (const nodeId of gcResult.deletedNodeIds) {
-			const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
-			if (nodeStateTracker === undefined) {
-				this.unreferencedNodesState.set(
-					nodeId,
-					new UnreferencedStateTracker(
-						currentReferenceTimestampMs,
-						this.configs.inactiveTimeoutMs,
-						currentReferenceTimestampMs,
-						this.configs.sweepTimeoutMs,
-					),
-				);
-			} else {
-				nodeStateTracker.updateTracking(currentReferenceTimestampMs);
-				if (nodeStateTracker.state === UnreferencedState.SweepReady) {
-					sweepReadyNodes.push(nodeId);
-				}
-			}
-		}
-
-		return sweepReadyNodes;
-	}
-
-	/**
-	 * Deletes nodes from both the runtime and garbage collection
-	 * @param sweepReadyNodes - nodes that are ready to be deleted
-	 */
-	private runSweepPhase(sweepReadyNodes: string[], gcData: IGarbageCollectionData) {
-		// TODO: GC:Validation - validate that removed routes are not double deleted
-		// TODO: GC:Validation - validate that the child routes of removed routes are deleted as well
-		const sweptRoutes = this.runtime.deleteSweepReadyNodes(sweepReadyNodes);
-		const updatedGCData = this.deleteSweptRoutes(sweptRoutes, gcData);
-
-		for (const nodeId of sweptRoutes) {
-			const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
-			// TODO: GC:Validation - assert that the nodeStateTracker is defined
-			if (nodeStateTracker !== undefined) {
-				// Stop tracking so as to clear out any running timers.
-				nodeStateTracker.stopTracking();
-				// Delete the node as we don't need to track it any more.
-				this.unreferencedNodesState.delete(nodeId);
-			}
-			// TODO: GC:Validation - assert that the deleted node is not a duplicate
-			this.deletedNodes.add(nodeId);
-		}
-
-		return updatedGCData;
-	}
-
-	/**
-	 * @returns IGarbageCollectionData after deleting the sweptRoutes from the gcData
-	 */
-	private deleteSweptRoutes(
-		sweptRoutes: string[],
-		gcData: IGarbageCollectionData,
-	): IGarbageCollectionData {
-		const sweptRoutesSet = new Set<string>(sweptRoutes);
-		const gcNodes: { [id: string]: string[] } = {};
-		for (const [id, outboundRoutes] of Object.entries(gcData.gcNodes)) {
-			if (!sweptRoutesSet.has(id)) {
-				gcNodes[id] = Array.from(outboundRoutes);
-			}
-		}
-
-		// TODO: GC:Validation - assert that the nodeId is in gcData
-
-		return {
-			gcNodes,
-		};
-	}
-
-	/**
-	 * Since GC runs periodically, the GC data that is generated only tells us the state of the world at that point in
-	 * time. There can be nodes that were referenced in between two runs and their unreferenced state needs to be
-	 * updated. For example, in the following scenarios not updating the unreferenced timestamp can lead to deletion of
-	 * these objects while there can be in-memory referenced to it:
-	 * 1. A node transitions from `unreferenced -> referenced -> unreferenced` between two runs. When the reference is
-	 * added, the object may have been accessed and in-memory reference to it added.
-	 * 2. A reference is added from one unreferenced node to one or more unreferenced nodes. Even though the node[s] were
-	 * unreferenced, they could have been accessed and in-memory reference to them added.
-	 *
-	 * This function identifies nodes that were referenced since the last run.
-	 * If these nodes are currently unreferenced, they will be assigned new unreferenced state by the current run.
-	 *
-	 * @returns - a list of all nodes referenced from the last local summary until now.
-	 */
-	private findAllNodesReferencedBetweenGCs(
-		currentGCData: IGarbageCollectionData,
-		previousGCData: IGarbageCollectionData | undefined,
-		logger: ITelemetryLogger,
-	): string[] | undefined {
-		// If we haven't run GC before there is nothing to do.
-		// No previousGCData, means nothing is unreferenced, and there are no reference state trackers to clear
-		if (previousGCData === undefined) {
-			return undefined;
-		}
-
-		// Find any references that haven't been identified correctly.
-		const missingExplicitReferences = this.findMissingExplicitReferences(
-			currentGCData,
-			previousGCData,
-			this.newReferencesSinceLastRun,
-		);
-
-		if (missingExplicitReferences.length > 0) {
-			missingExplicitReferences.forEach((missingExplicitReference) => {
-				logger.sendErrorEvent({
-					eventName: "gcUnknownOutboundReferences",
-					gcNodeId: missingExplicitReference[0],
-					gcRoutes: JSON.stringify(missingExplicitReference[1]),
-				});
-			});
-		}
-
-		// No references were added since the last run so we don't have to update reference states of any unreferenced
-		// nodes. There is no in between state at this point.
-		if (this.newReferencesSinceLastRun.size === 0) {
-			return undefined;
-		}
-
-		/**
-		 * Generate a super set of the GC data that contains the nodes and edges from last run, plus any new node and
-		 * edges that have been added since then. To do this, combine the GC data from the last run and the current
-		 * run, and then add the references since last run.
-		 *
-		 * Note on why we need to combine the data from previous run, current run and all references in between -
-		 * 1. We need data from last run because some of its references may have been deleted since then. If those
-		 * references added new outbound references before they were deleted, we need to detect them.
-		 *
-		 * 2. We need new outbound references since last run because some of them may have been deleted later. If those
-		 * references added new outbound references before they were deleted, we need to detect them.
-		 *
-		 * 3. We need data from the current run because currently we may not detect when DDSes are referenced:
-		 * - We don't require DDSes handles to be stored in a referenced DDS.
-		 * - A new data store may have "root" DDSes already created and we don't detect them today.
-		 */
-		const gcDataSuperSet = concatGarbageCollectionData(previousGCData, currentGCData);
-		const newOutboundRoutesSinceLastRun: string[] = [];
-		this.newReferencesSinceLastRun.forEach((outboundRoutes: string[], sourceNodeId: string) => {
-			if (gcDataSuperSet.gcNodes[sourceNodeId] === undefined) {
-				gcDataSuperSet.gcNodes[sourceNodeId] = outboundRoutes;
-			} else {
-				gcDataSuperSet.gcNodes[sourceNodeId].push(...outboundRoutes);
-			}
-			newOutboundRoutesSinceLastRun.push(...outboundRoutes);
-		});
-
-		/**
-		 * Run GC on the above reference graph starting with root and all new outbound routes. This will generate a
-		 * list of all nodes that could have been referenced since the last run. If any of these nodes are unreferenced,
-		 * unreferenced, stop tracking them and remove from unreferenced list.
-		 * Note that some of these nodes may be unreferenced now and if so, the current run will mark them as
-		 * unreferenced and add unreferenced state.
-		 */
-		const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, [
-			"/",
-			...newOutboundRoutesSinceLastRun,
-		]);
-		return gcResult.referencedNodeIds;
-	}
-
-	/**
-	 * Finds 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.
-	 * @returns - a list of missing explicit references
-	 */
-	private findMissingExplicitReferences(
-		currentGCData: IGarbageCollectionData,
-		previousGCData: IGarbageCollectionData,
-		explicitReferences: Map<string, string[]>,
-	): [string, string[]][] {
-		assert(
-			previousGCData !== undefined,
-			0x2b7 /* "Can't validate correctness without GC data from last run" */,
-		);
-
-		const currentGraph = Object.entries(currentGCData.gcNodes);
-		const missingExplicitReferences: [string, string[]][] = [];
-		currentGraph.forEach(([nodeId, currentOutboundRoutes]) => {
-			const previousRoutes = previousGCData.gcNodes[nodeId] ?? [];
-			const explicitRoutes = explicitReferences.get(nodeId) ?? [];
-			const missingExplicitRoutes: string[] = [];
-
-			/**
-			 * 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.
-			 */
-			currentOutboundRoutes.forEach((route) => {
-				const nodeType = this.runtime.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) {
-				missingExplicitReferences.push([nodeId, missingExplicitRoutes]);
-			}
-		});
-
-		// Ideally missingExplicitReferences should always have a size 0
-		return missingExplicitReferences;
-	}
-
 	/**
 	 * Generates the stats of a garbage collection run from the given results of the run.
 	 * @param gcResult - The result of a GC run.
@@ -1081,171 +1003,4 @@ export class GarbageCollector implements IGarbageCollector {
 
 		return gcStats;
 	}
-
-	/**
-	 * 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.
-	 */
-	private logSweepEvents(logger: ITelemetryLogger, currentReferenceTimestampMs: number) {
-		if (
-			this.mc.config.getBoolean(disableSweepLogKey) === true ||
-			this.configs.sweepTimeoutMs === undefined
-		) {
-			return;
-		}
-
-		this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
-			if (nodeStateTracker.state !== UnreferencedState.SweepReady) {
-				return;
-			}
-
-			const nodeType = this.runtime.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: this.completedRuns,
-				lastSummaryTime: this.getLastSummaryTimestampMs(),
-			});
-		});
-	}
-
-	/**
-	 * Called when an inactive node is used after. Queue up an event that will be logged next time GC runs.
-	 */
-	private inactiveNodeUsed(
-		usageType: "Changed" | "Loaded" | "Revived",
-		nodeId: string,
-		nodeStateTracker: UnreferencedStateTracker,
-		fromNodeId?: string,
-		packagePath?: readonly string[],
-		currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs(),
-		requestHeaders?: IRequestHeader,
-	) {
-		// 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 active, skip logging.
-		if (
-			currentReferenceTimestampMs === undefined ||
-			nodeStateTracker.state === UnreferencedState.Active
-		) {
-			return;
-		}
-
-		// We only care about data stores and attachment blobs for this telemetry since GC only marks these objects
-		// as unreferenced. Also, if an inactive DDS is used, the corresponding data store store will also be used.
-		const nodeType = this.runtime.getNodeType(nodeId);
-		if (nodeType !== GCNodeType.DataStore && nodeType !== GCNodeType.Blob) {
-			return;
-		}
-
-		const state = nodeStateTracker.state;
-		const uniqueEventId = `${state}-${nodeId}-${usageType}`;
-		if (this.loggedUnreferencedEvents.has(uniqueEventId)) {
-			return;
-		}
-		this.loggedUnreferencedEvents.add(uniqueEventId);
-
-		const propsToLog = {
-			id: nodeId,
-			type: nodeType,
-			unrefTime: nodeStateTracker.unreferencedTimestampMs,
-			age: currentReferenceTimestampMs - nodeStateTracker.unreferencedTimestampMs,
-			timeout:
-				nodeStateTracker.state === UnreferencedState.Inactive
-					? this.configs.inactiveTimeoutMs
-					: this.configs.sweepTimeoutMs,
-			completedGCRuns: this.completedRuns,
-			lastSummaryTime: this.getLastSummaryTimestampMs(),
-			...this.createContainerMetadata,
-			viaHandle: requestHeaders?.[RuntimeHeaders.viaHandle],
-			fromId: fromNodeId,
-		};
-
-		// 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({ ...propsToLog, 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 (usageType === "Loaded") {
-				const event = {
-					...propsToLog,
-					eventName: `${state}Object_${usageType}`,
-					pkg: packagePathToTelemetryProperty(packagePath),
-					stack: generateStack(),
-				};
-
-				// 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);
-				}
-			}
-		}
-	}
-
-	private async logUnreferencedEvents(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.unreferencedNodesState.get(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 = [];
-	}
 }