@fluidframework/container-runtime 1.1.0 → 1.2.0

package/dist/garbageCollection.js

@@ -3,8 +3,19 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GarbageCollector = exports.GCNodeType = exports.defaultSessionExpiryDurationMs = exports.trackGCStateKey = exports.disableSessionExpiryKey = exports.runSessionExpiryKey = exports.gcBlobPrefix = exports.gcTreeKey = void 0;
+exports.GarbageCollector = exports.GCNodeType = exports.defaultSessionExpiryDurationMs = exports.oneDayMs = exports.trackGCStateKey = exports.disableSessionExpiryKey = exports.runSessionExpiryKey = exports.gcBlobPrefix = exports.gcTreeKey = void 0;
 const common_utils_1 = require("@fluidframework/common-utils");
 const container_utils_1 = require("@fluidframework/container-utils");
 const garbage_collector_1 = require("@fluidframework/garbage-collector");
@@ -23,10 +34,10 @@ exports.gcTreeKey = "gc";
 exports.gcBlobPrefix = "__gc";
 // Feature gate key to turn GC on / off.
 const runGCKey = "Fluid.GarbageCollection.RunGC";
-// Feature gate key to turn GC test mode on / off.
-const gcTestModeKey = "Fluid.GarbageCollection.GCTestMode";
 // Feature gate key to turn GC sweep on / off.
 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.
 const writeAtRootKey = "Fluid.GarbageCollection.WriteDataAtRoot";
 // Feature gate key to expire a session after a set period of time.
@@ -35,8 +46,12 @@ exports.runSessionExpiryKey = "Fluid.GarbageCollection.RunSessionExpiry";
 exports.disableSessionExpiryKey = "Fluid.GarbageCollection.DisableSessionExpiry";
 // Feature gate key to write the gc blob as a handle if the data is the same.
 exports.trackGCStateKey = "Fluid.GarbageCollection.TrackGCState";
-const defaultInactiveTimeoutMs = 7 * 24 * 60 * 60 * 1000; // 7 days
-exports.defaultSessionExpiryDurationMs = 30 * 24 * 60 * 60 * 1000; // 30 days
+// Feature gate key to turn GC sweep log off.
+const disableSweepLogKey = "Fluid.GarbageCollection.DisableSweepLog";
+// One day in milliseconds.
+exports.oneDayMs = 1 * 24 * 60 * 60 * 1000;
+const defaultInactiveTimeoutMs = 7 * exports.oneDayMs; // 7 days
+exports.defaultSessionExpiryDurationMs = 30 * exports.oneDayMs; // 30 days
 /** The types of GC nodes in the GC reference graph. */
 exports.GCNodeType = {
     // Nodes that are for data stores.
@@ -48,50 +63,84 @@ exports.GCNodeType = {
     // Nodes that are neither of the above. For example, root node.
     Other: "Other",
 };
+/** The state of node that is unreferenced. */
+const UnreferencedState = {
+    /** The node is active, i.e., it can become referenced again. */
+    Active: "Active",
+    /** The node is inactive, i.e., it should not become referenced. */
+    Inactive: "Inactive",
+    /** The node is ready to be deleted by the sweep phase. */
+    SweepReady: "SweepReady",
+};
 /**
- * Helper class that tracks the state of an unreferenced node such as the time it was unreferenced. It also sets
- * the node's state to inactive if it remains unreferenced for a given amount of time (inactiveTimeoutMs).
+ * Helper class that tracks the state of an unreferenced node such as the time it was unreferenced and if it can
+ * be deleted by the sweep phase.
  */
 class UnreferencedStateTracker {
-    constructor(unreferencedTimestampMs, inactiveTimeoutMs, currentReferenceTimestampMs) {
+    constructor(unreferencedTimestampMs, 
+    /** The time after which node transitions to Inactive state. */
+    inactiveTimeoutMs, 
+    /** The time after which node transitions to SweepReady state; undefined if session expiry is disabled. */
+    sweepTimeoutMs, 
+    /** The current reference timestamp; undefined if no ops have ever been processed which can happen in tests. */
+    currentReferenceTimestampMs) {
         this.unreferencedTimestampMs = unreferencedTimestampMs;
         this.inactiveTimeoutMs = inactiveTimeoutMs;
-        this._inactive = false;
-        // If there is no current reference timestamp, don't track the node's inactive state. This will happen later
-        // when updateTracking is called with a reference timestamp.
+        this.sweepTimeoutMs = sweepTimeoutMs;
+        this._state = UnreferencedState.Active;
+        // If there is no current reference timestamp, don't track the node's unreferenced state. This will happen
+        // later when updateTracking is called with a reference timestamp.
         if (currentReferenceTimestampMs !== undefined) {
             this.updateTracking(currentReferenceTimestampMs);
         }
     }
-    get inactive() {
-        return this._inactive;
+    get state() {
+        return this._state;
     }
-    /**
-     * Updates the tracking state based on the provided timestamp.
-     */
+    /* Updates the unreferenced state based on the provided timestamp. */
     updateTracking(currentReferenceTimestampMs) {
-        var _a;
         const unreferencedDurationMs = currentReferenceTimestampMs - this.unreferencedTimestampMs;
-        // If the timeout has already expired, the node has become inactive.
-        if (unreferencedDurationMs > this.inactiveTimeoutMs) {
-            this._inactive = true;
-            (_a = this.timer) === null || _a === void 0 ? void 0 : _a.clear();
+        // If the node has been unreferenced for sweep timeout amount of time, update the state to SweepReady.
+        if (this.sweepTimeoutMs !== undefined && unreferencedDurationMs >= this.sweepTimeoutMs) {
+            this._state = UnreferencedState.SweepReady;
+            this.clearTimers();
+            return;
+        }
+        // If the node has been unreferenced for inactive timeoutMs amount of time, update the state to inactive.
+        // Also, start a timer for the sweep timeout.
+        if (unreferencedDurationMs >= this.inactiveTimeoutMs) {
+            this._state = UnreferencedState.Inactive;
+            this.clearTimers();
+            if (this.sweepTimeoutMs !== undefined) {
+                setLongTimeout(this.sweepTimeoutMs - unreferencedDurationMs, () => { this._state = UnreferencedState.SweepReady; }, (timer) => { this.sweepTimer = timer; });
+            }
             return;
         }
-        // The node isn't inactive yet. Restart a timer for the duration remaining for it to become inactive.
+        // The node is still active. Start the inactive timer for the remaining duration.
         const remainingDurationMs = this.inactiveTimeoutMs - unreferencedDurationMs;
-        if (this.timer === undefined) {
-            this.timer = new common_utils_1.Timer(remainingDurationMs, () => { this._inactive = true; });
+        if (this.inactiveTimer === undefined) {
+            const inactiveTimeoutHandler = () => {
+                this._state = UnreferencedState.Inactive;
+                // After the node becomes inactive, start the sweep timer after which the node will be ready for sweep.
+                if (this.sweepTimeoutMs !== undefined) {
+                    setLongTimeout(this.sweepTimeoutMs - this.inactiveTimeoutMs, () => { this._state = UnreferencedState.SweepReady; }, (timer) => { this.sweepTimer = timer; });
+                }
+            };
+            this.inactiveTimer = new common_utils_1.Timer(remainingDurationMs, () => inactiveTimeoutHandler());
         }
-        this.timer.restart(remainingDurationMs);
+        this.inactiveTimer.restart(remainingDurationMs);
     }
-    /**
-     * Stop tracking this node. Reset the unreferenced timer, if any, and reset inactive state.
-     */
-    stopTracking() {
+    clearTimers() {
         var _a;
-        (_a = this.timer) === null || _a === void 0 ? void 0 : _a.clear();
-        this._inactive = false;
+        (_a = this.inactiveTimer) === null || _a === void 0 ? void 0 : _a.clear();
+        if (this.sweepTimer !== undefined) {
+            clearTimeout(this.sweepTimer);
+        }
+    }
+    /** Stop tracking this node. Reset the unreferenced timers and state, if any. */
+    stopTracking() {
+        this.clearTimers();
+        this._state = UnreferencedState.Active;
     }
 }
 /**
@@ -184,20 +233,21 @@ class GarbageCollector {
                 this.sessionExpiryTimeoutMs = exports.defaultSessionExpiryDurationMs;
             }
         }
-        // If session expiry is enabled, we need to close the container when the timeout expires
-        if (this.sessionExpiryTimeoutMs !== undefined
-            && this.mc.config.getBoolean(exports.disableSessionExpiryKey) !== true) {
-            // If Test Override config is set, override Session Expiry timeout
+        // If session expiry is enabled, we need to close the container when the session expiry timeout expires.
+        if (this.sessionExpiryTimeoutMs !== undefined && this.mc.config.getBoolean(exports.disableSessionExpiryKey) !== true) {
+            // If Test Override config is set, override Session Expiry timeout.
             const overrideSessionExpiryTimeoutMs = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.SessionExpiryMs");
-            if (overrideSessionExpiryTimeoutMs !== undefined) {
-                this.sessionExpiryTimeoutMs = overrideSessionExpiryTimeoutMs;
+            const timeoutMs = overrideSessionExpiryTimeoutMs !== null && overrideSessionExpiryTimeoutMs !== void 0 ? overrideSessionExpiryTimeoutMs : this.sessionExpiryTimeoutMs;
+            setLongTimeout(timeoutMs, () => { this.runtime.closeFn(new container_utils_1.ClientSessionExpiredError(`Client session expired.`, timeoutMs)); }, (timer) => { this.sessionExpiryTimer = timer; });
+            /**
+             * 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 + exports.oneDayMs;
             }
-            const timeoutMs = this.sessionExpiryTimeoutMs;
-            setLongTimeout(timeoutMs, () => {
-                this.runtime.closeFn(new container_utils_1.ClientSessionExpiredError(`Client session expired.`, timeoutMs));
-            }, (timer) => {
-                this.sessionExpiryTimer = timer;
-            });
         }
         // For existing document, the latest summary is the one that we loaded from. So, use its GC version as the
         // latest tracked GC version. For new documents, we will be writing the first summary with the current version.
@@ -213,17 +263,23 @@ class GarbageCollector {
         this.gcEnabled
             // GC must not be disabled via GC options.
             && !this.gcOptions.disableGC);
-        this.trackGCState = this.mc.config.getBoolean(exports.trackGCStateKey) === true;
         /**
          * Whether sweep should run or not. The following conditions have to be met to run sweep:
          * 1. Overall GC or mark phase must be enabled (this.shouldRunGC).
-         * 2. Session expiry and sweep should be enabled for this container. Without session expiry we cannot safely
-         *    delete unreferenced objects. This condition (#2) can be overridden via runSweepKey feature flag.
+         * 2. Sweep timeout should be available. Without this, we wouldn't know when an object should be deleted.
+         * 3. Sweep should be enabled for this container (this.sweepEnabled). This can be overridden via runSweep
+         *    feature flag.
          */
-        this.shouldRunSweep = this.shouldRunGC && ((_c = this.mc.config.getBoolean(runSweepKey)) !== null && _c !== void 0 ? _c : (this.sessionExpiryTimeoutMs !== undefined && this.sweepEnabled));
+        this.shouldRunSweep = this.shouldRunGC
+            && this.sweepTimeoutMs !== undefined
+            && ((_c = this.mc.config.getBoolean(runSweepKey)) !== null && _c !== void 0 ? _c : this.sweepEnabled);
+        this.trackGCState = this.mc.config.getBoolean(exports.trackGCStateKey) === true;
         // Override inactive timeout if test config or gc options to override it is set.
-        this.inactiveTimeoutMs =
-            (_e = (_d = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _d !== void 0 ? _d : this.gcOptions.inactiveTimeoutMs) !== null && _e !== void 0 ? _e : defaultInactiveTimeoutMs;
+        this.inactiveTimeoutMs = (_e = (_d = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _d !== void 0 ? _d : this.gcOptions.inactiveTimeoutMs) !== null && _e !== void 0 ? _e : defaultInactiveTimeoutMs;
+        // Inactive timeout must be greater than sweep timeout since a node goes from active -> inactive -> sweep ready.
+        if (this.sweepTimeoutMs !== undefined && this.inactiveTimeoutMs > this.sweepTimeoutMs) {
+            throw new container_utils_1.UsageError("inactive timeout should not be greated than the sweep timeout");
+        }
         // Whether we are running in test mode. In this mode, unreferenced nodes are immediately deleted.
         this.testMode = (_f = this.mc.config.getBoolean(gcTestModeKey)) !== null && _f !== void 0 ? _f : this.gcOptions.runGCInTestMode === true;
         // GC state is written into root of the summary tree by default. Can be overridden via feature flag for now.
@@ -302,7 +358,7 @@ class GarbageCollector {
             const gcNodes = {};
             for (const [nodeId, nodeData] of Object.entries(baseState.gcNodes)) {
                 if (nodeData.unreferencedTimestampMs !== undefined) {
-                    this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs));
+                    this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.inactiveTimeoutMs, this.sweepTimeoutMs, currentReferenceTimestampMs));
                 }
                 gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
             }
@@ -338,7 +394,7 @@ class GarbageCollector {
         });
         // Log all the GC options and the state determined by the garbage collector. This is interesting only for the
         // summarizer client since it is the only one that runs GC. It also helps keep the telemetry less noisy.
-        const gcConfigProps = JSON.stringify(Object.assign({ gcEnabled: this.gcEnabled, sweepEnabled: this.sweepEnabled, runGC: this.shouldRunGC, runSweep: this.shouldRunSweep, writeAtRoot: this._writeDataAtRoot, testMode: this.testMode, sessionExpiry: this.sessionExpiryTimeoutMs, inactiveTimeout: this.inactiveTimeoutMs, existing: createParams.existing }, this.gcOptions));
+        const gcConfigProps = JSON.stringify(Object.assign({ gcEnabled: this.gcEnabled, sweepEnabled: this.sweepEnabled, runGC: this.shouldRunGC, runSweep: this.shouldRunSweep, writeAtRoot: this._writeDataAtRoot, testMode: this.testMode, sessionExpiry: this.sessionExpiryTimeoutMs, inactiveTimeout: this.inactiveTimeoutMs, existing: createParams.existing, trackGCState: this.trackGCState }, this.gcOptions));
         if (this.isSummarizerClient) {
             this.mc.logger.sendTelemetryEvent({
                 eventName: "GarbageCollectorLoaded",
@@ -377,38 +433,52 @@ class GarbageCollector {
      * @returns the number of data stores that have been marked as unreferenced.
      */
     async collectGarbage(options) {
-        const { runSweep = this.shouldRunSweep, fullGC = this.gcOptions.runFullGC === true || this.summaryStateNeedsReset, } = options;
+        const { fullGC = this.gcOptions.runFullGC === true || this.summaryStateNeedsReset, } = options;
         const logger = options.logger
             ? telemetry_utils_1.ChildLogger.create(options.logger, undefined, { all: { completedGCRuns: () => this.completedRuns } })
             : this.mc.logger;
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(logger, { eventName: "GarbageCollection" }, async (event) => {
-            await this.initializeBaseStateP;
-            // Let the runtime update its pending state before GC runs.
-            await this.runtime.updateStateBeforeGC();
+            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 = (0, garbage_collector_1.runGarbageCollection)(gcData.gcNodes, ["/"]);
-            const gcStats = this.generateStatsAndLogEvents(gcResult, logger);
-            // Update the state since the last GC run. There can be nodes that were referenced between the last and
-            // the current run. We need to identify than and update their unreferenced state if needed.
-            this.updateStateSinceLastRun(gcData, logger);
-            // Update the current state of the system based on the GC run.
-            const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
-            this.updateCurrentState(gcData, gcResult, currentReferenceTimestampMs);
-            this.runtime.updateUsedRoutes(gcResult.referencedNodeIds, currentReferenceTimestampMs);
-            if (runSweep) {
-                // Placeholder for running sweep logic.
-            }
-            // If we are running in GC test mode, delete objects for unused routes. This enables testing scenarios
-            // involving access to deleted data.
-            if (this.testMode) {
-                this.runtime.deleteUnusedRoutes(gcResult.deletedNodeIds);
-            }
+            const gcStats = await this.runPostGCSteps(gcData, gcResult, logger);
             event.end(Object.assign({}, gcStats));
             this.completedRuns++;
             return gcStats;
         }, { end: true, cancel: "error" });
     }
+    async runPreGCSteps() {
+        // Ensure that base state has been initialized.
+        await this.initializeBaseStateP;
+        // Let the runtime update its pending state before GC runs.
+        await this.runtime.updateStateBeforeGC();
+    }
+    async runPostGCSteps(gcData, gcResult, logger) {
+        // 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.
+        const gcStats = this.generateStats(gcResult);
+        // Update the state since the last GC run. There can be nodes that were referenced between the last and
+        // the current run. We need to identify than and update their unreferenced state if needed.
+        this.updateStateSinceLastRun(gcData, logger);
+        // Update the current state and update the runtime of all routes or ids that used as per the GC run.
+        const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
+        this.updateCurrentState(gcData, gcResult, currentReferenceTimestampMs);
+        this.runtime.updateUsedRoutes(gcResult.referencedNodeIds, currentReferenceTimestampMs);
+        // 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);
+        // If we are running in GC test mode, delete objects for unused routes. This enables testing scenarios
+        // involving access to deleted data.
+        if (this.testMode) {
+            this.runtime.deleteUnusedRoutes(gcResult.deletedNodeIds);
+        }
+        // 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);
+        return gcStats;
+    }
     /**
      * Summarizes the GC data and returns it as a summary tree.
      * We current write the entire GC state in a single blob. This can be modified later to write multiple
@@ -520,7 +590,10 @@ class GarbageCollector {
         if (!this.shouldRunGC) {
             return;
         }
-        this.logIfInactive(reason, nodePath, timestampMs, packagePath, requestHeaders);
+        const nodeStateTracker = this.unreferencedNodesState.get(nodePath);
+        if (nodeStateTracker && nodeStateTracker.state !== UnreferencedState.Active) {
+            this.inactiveNodeUsed(reason, nodePath, nodeStateTracker, undefined /* fromNodeId */, packagePath, timestampMs, requestHeaders);
+        }
     }
     /**
      * Called when an outbound reference is added to a node. This is used to identify all nodes that have been
@@ -537,8 +610,10 @@ class GarbageCollector {
         const outboundRoutes = (_a = this.newReferencesSinceLastRun.get(fromNodePath)) !== null && _a !== void 0 ? _a : [];
         outboundRoutes.push(toNodePath);
         this.newReferencesSinceLastRun.set(fromNodePath, outboundRoutes);
-        // If the node that got referenced is inactive, log an event as that may indicate use-after-delete.
-        this.logIfInactive("Revived", toNodePath);
+        const nodeStateTracker = this.unreferencedNodesState.get(toNodePath);
+        if (nodeStateTracker && nodeStateTracker.state !== UnreferencedState.Active) {
+            this.inactiveNodeUsed("Revived", toNodePath, nodeStateTracker, fromNodePath);
+        }
     }
     dispose() {
         if (this.sessionExpiryTimer !== undefined) {
@@ -584,7 +659,7 @@ class GarbageCollector {
         for (const nodeId of gcResult.deletedNodeIds) {
             const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
             if (nodeStateTracker === undefined) {
-                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(currentReferenceTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs));
+                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(currentReferenceTimestampMs, this.inactiveTimeoutMs, this.sweepTimeoutMs, currentReferenceTimestampMs));
             }
             else {
                 nodeStateTracker.updateTracking(currentReferenceTimestampMs);
@@ -631,10 +706,10 @@ class GarbageCollector {
          *    references added new outbound references before getting 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 getting deleted, we need to detect them.
-         * 3. We need data from the current run because currently we may not detect when DDSs are referenced:
-         *    - We don't require DDSs handles to be stored in a referenced DDS. For this, we need GC at DDS level
+         * 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. For this, we need GC at DDS level
          *      which is tracked by https://github.com/microsoft/FluidFramework/issues/8470.
-         *    - A new data store may have "root" DDSs already created and we don't detect them today.
+         *    - A new data store may have "root" DDSes already created and we don't detect them today.
          */
         const gcDataSuperSet = (0, garbage_collector_1.concatGarbageCollectionData)(this.previousGCDataFromLastRun, currentGCData);
         this.newReferencesSinceLastRun.forEach((outboundRoutes, sourceNodeId) => {
@@ -702,21 +777,11 @@ class GarbageCollector {
         return missingExplicitReferences;
     }
     /**
-     * Generates the stats of a garbage collection run from the given results of the run. Also, logs any pending events
-     * in the pendingEventsQueue. This should be called before updating the current state because it generates stats
-     * based on previous state of the system.
+     * Generates the stats of a garbage collection run from the given results of the run.
      * @param gcResult - The result of a GC run.
      * @returns the GC stats of the GC run.
      */
-    generateStatsAndLogEvents(gcResult, logger) {
-        // Log pending events for unreferenced nodes after GC has run. We should have the package data available for
-        // them now since the GC run should have loaded these nodes.
-        let event = this.pendingEventsQueue.shift();
-        while (event !== undefined) {
-            const pkg = this.getNodePackagePath(event.id);
-            logger.sendErrorEvent(Object.assign(Object.assign({}, event), { pkg: pkg ? { value: `/${pkg.join("/")}`, tag: telemetry_utils_1.TelemetryDataTag.PackageData } : undefined }));
-            event = this.pendingEventsQueue.shift();
-        }
+    generateStats(gcResult) {
         const gcStats = {
             nodeCount: 0,
             dataStoreCount: 0,
@@ -768,12 +833,53 @@ class GarbageCollector {
         return gcStats;
     }
     /**
-     * Logs an event if a node is inactive and is used.
+     * 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.
      */
-    logIfInactive(eventType, nodeId, currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs(), packagePath, requestHeaders) {
+    logSweepEvents(logger, currentReferenceTimestampMs) {
+        if (this.mc.config.getBoolean(disableSweepLogKey) === true
+            || currentReferenceTimestampMs === undefined
+            || this.sweepTimeoutMs === undefined) {
+            return;
+        }
+        this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
+            if (nodeStateTracker.state !== UnreferencedState.SweepReady) {
+                return;
+            }
+            const nodeType = this.runtime.getNodeType(nodeId);
+            if (nodeType !== exports.GCNodeType.DataStore && nodeType !== exports.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.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.
+     */
+    inactiveNodeUsed(usageType, nodeId, nodeStateTracker, fromNodeId, packagePath, currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs(), requestHeaders) {
         // 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 (currentReferenceTimestampMs === undefined) {
+        // If the node is active, skip logging.
+        if (currentReferenceTimestampMs === undefined || nodeStateTracker.state === UnreferencedState.Active) {
+            return;
+        }
+        // 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).
+        if (!this.isSummarizerClient && usageType !== "Loaded") {
             return;
         }
         // We only care about data stores and attachment blobs for this telemetry since GC only marks these objects
@@ -782,39 +888,54 @@ class GarbageCollector {
         if (nodeType !== exports.GCNodeType.DataStore && nodeType !== exports.GCNodeType.Blob) {
             return;
         }
-        // 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).
-        if (!this.isSummarizerClient && eventType !== "Loaded") {
+        const state = nodeStateTracker.state;
+        const uniqueEventId = `${state}-${nodeId}-${usageType}`;
+        if (this.loggedUnreferencedEvents.has(uniqueEventId)) {
             return;
         }
-        const eventName = `inactiveObject_${eventType}`;
-        // We log a particular event for a given node only once so that it is not too noisy.
-        const uniqueEventId = `${nodeId}-${eventName}`;
-        const nodeState = this.unreferencedNodesState.get(nodeId);
-        if ((nodeState === null || nodeState === void 0 ? void 0 : nodeState.inactive) && !this.loggedUnreferencedEvents.has(uniqueEventId)) {
-            this.loggedUnreferencedEvents.add(uniqueEventId);
-            // Save all the properties at this point in time so that if we log this later, these values are preserved.
-            const event = {
-                eventName,
-                id: nodeId,
-                type: nodeType,
-                age: currentReferenceTimestampMs - nodeState.unreferencedTimestampMs,
-                timeout: this.inactiveTimeoutMs,
-                completedGCRuns: this.completedRuns,
-                lastSummaryTime: this.getLastSummaryTimestampMs(),
-                externalRequest: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[containerRuntime_1.RuntimeHeaders.externalRequest],
-                viaHandle: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[containerRuntime_1.RuntimeHeaders.viaHandle],
-            };
-            // If the package data for the node exists, log immediately. Otherwise, queue it and it will be logged the
-            // next time GC runs as the package data should be available then.
-            const pkg = packagePath !== null && packagePath !== void 0 ? packagePath : this.getNodePackagePath(nodeId);
-            if (pkg !== undefined) {
-                this.mc.logger.sendErrorEvent(Object.assign(Object.assign({}, event), { pkg: { value: pkg.join("/"), tag: telemetry_utils_1.TelemetryDataTag.PackageData } }));
-            }
-            else {
-                this.pendingEventsQueue.push(event);
+        this.loggedUnreferencedEvents.add(uniqueEventId);
+        const propsToLog = {
+            id: nodeId,
+            type: nodeType,
+            unrefTime: nodeStateTracker.unreferencedTimestampMs,
+            age: currentReferenceTimestampMs - nodeStateTracker.unreferencedTimestampMs,
+            timeout: nodeStateTracker.state === UnreferencedState.Inactive
+                ? this.inactiveTimeoutMs
+                : this.sweepTimeoutMs,
+            completedGCRuns: this.completedRuns,
+            lastSummaryTime: this.getLastSummaryTimestampMs(),
+            externalRequest: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[containerRuntime_1.RuntimeHeaders.externalRequest],
+            viaHandle: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[containerRuntime_1.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.
+        if (this.isSummarizerClient) {
+            this.pendingEventsQueue.push(Object.assign(Object.assign({}, propsToLog), { usageType, state }));
+        }
+        else {
+            this.mc.logger.sendErrorEvent(Object.assign(Object.assign({}, propsToLog), { eventName: `${state}Object_${usageType}`, pkg: packagePath ? { value: packagePath.join("/"), tag: telemetry_utils_1.TelemetryDataTag.CodeArtifact } : undefined }));
+        }
+    }
+    async logUnreferencedEvents(logger) {
+        for (const eventProps of this.pendingEventsQueue) {
+            const { usageType, state } = eventProps, propsToLog = __rest(eventProps, ["usageType", "state"]);
+            /**
+             * 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;
+                logger.sendErrorEvent(Object.assign(Object.assign({}, propsToLog), { eventName: `${state}Object_${usageType}`, pkg: pkg ? { value: pkg.join("/"), tag: telemetry_utils_1.TelemetryDataTag.CodeArtifact } : undefined, fromPkg: fromPkg ? { value: fromPkg.join("/"), tag: telemetry_utils_1.TelemetryDataTag.CodeArtifact } : undefined }));
             }
         }
+        this.pendingEventsQueue = [];
     }
 }
 exports.GarbageCollector = GarbageCollector;