@fluidframework/container-runtime 2.0.0-internal.3.2.1 → 2.0.0-internal.3.3.0

package/lib/gc/garbageCollection.js

@@ -14,16 +14,15 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { assert, LazyPromise, Timer } from "@fluidframework/common-utils";
-import { ClientSessionExpiredError, DataProcessingError, UsageError, } from "@fluidframework/container-utils";
+import { ClientSessionExpiredError, DataProcessingError } from "@fluidframework/container-utils";
 import { cloneGCData, concatGarbageCollectionData, getGCDataFromSnapshot, runGarbageCollection, trimLeadingSlashes, } from "@fluidframework/garbage-collector";
 import { gcTreeKey, } from "@fluidframework/runtime-definitions";
 import { packagePathToTelemetryProperty, } from "@fluidframework/runtime-utils";
 import { ChildLogger, generateStack, loggerToMonitoringContext, PerformanceEvent, TelemetryDataTag, } from "@fluidframework/telemetry-utils";
 import { RuntimeHeaders } from "../containerRuntime";
-import { getSummaryForDatastores } from "../dataStores";
-import { dataStoreAttributesBlobName, } from "../summary";
-import { defaultInactiveTimeoutMs, defaultSessionExpiryDurationMs, disableSweepLogKey, disableTombstoneKey, GCNodeType, gcTestModeKey, oneDayMs, runGCKey, runSessionExpiryKey, runSweepKey, trackGCStateKey, gcTombstoneGenerationOptionName, UnreferencedState, } from "./gcDefinitions";
-import { getGCVersion, sendGCUnexpectedUsageEvent } from "./gcHelpers";
+import { generateGCConfigs } from "./gcConfigs";
+import { disableSweepLogKey, GCNodeType, UnreferencedState, } from "./gcDefinitions";
+import { getSnapshotDataFromOldSnapshotFormat, sendGCUnexpectedUsageEvent } from "./gcHelpers";
 import { GCSummaryStateTracker } from "./gcSummaryStateTracker";
 import { SweepReadyUsageDetectionHandler } from "./gcSweepReadyUsageDetection";
 import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";
@@ -51,7 +50,6 @@ import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";
  */
 export class GarbageCollector {
     constructor(createParams) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
         // Keeps a list of references (edges in the GC graph) between GC runs. Each entry has a node id and a list of
         // outbound routes from that node.
         this.newReferencesSinceLastRun = new Map();
@@ -70,136 +68,31 @@ export class GarbageCollector {
         this.completedRuns = 0;
         this.runtime = createParams.runtime;
         this.isSummarizerClient = createParams.isSummarizerClient;
-        this.gcOptions = createParams.gcOptions;
         this.createContainerMetadata = createParams.createContainerMetadata;
         this.getNodePackagePath = createParams.getNodePackagePath;
         this.getLastSummaryTimestampMs = createParams.getLastSummaryTimestampMs;
         this.activeConnection = createParams.activeConnection;
         const baseSnapshot = createParams.baseSnapshot;
-        const metadata = createParams.metadata;
         const readAndParseBlob = createParams.readAndParseBlob;
         this.mc = loggerToMonitoringContext(ChildLogger.create(createParams.baseLogger, "GarbageCollector", {
             all: { completedGCRuns: () => this.completedRuns },
         }));
         this.sweepReadyUsageHandler = new SweepReadyUsageDetectionHandler(createParams.getContainerDiagnosticId(), this.mc, this.runtime.closeFn);
-        let gcVersionInBaseSnapshot;
-        /**
-         * 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 snapshot cache expiry timeout cannot be known precisely but the upper bound is 5 days.
-         * The buffer is added to account for any clock skew or other edge cases.
-         * We use server timestamps throughout so the skew should be minimal but make it 1 day to be safe.
-         */
-        function computeSweepTimeout(sessionExpiryTimeoutMs) {
-            const maxSnapshotCacheExpiryMs = 5 * oneDayMs;
-            const bufferMs = oneDayMs;
-            return (sessionExpiryTimeoutMs &&
-                sessionExpiryTimeoutMs + maxSnapshotCacheExpiryMs + bufferMs);
-        }
-        /**
-         * The following GC state is enabled during container creation and cannot be changed throughout its lifetime:
-         * 1. Whether running GC mark phase is allowed or not.
-         * 2. Whether running GC sweep phase is allowed or not.
-         * 3. Whether GC session expiry is enabled or not.
-         * For existing containers, we get this information from the metadata blob of its summary.
-         */
-        if (createParams.existing) {
-            gcVersionInBaseSnapshot = getGCVersion(metadata);
-            // Existing documents which did not have metadata blob or had GC disabled have version as 0. For all
-            // other existing documents, GC is enabled.
-            this.gcEnabled = gcVersionInBaseSnapshot > 0;
-            this.sweepEnabled = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.sweepEnabled) !== null && _a !== void 0 ? _a : false;
-            this.sessionExpiryTimeoutMs = metadata === null || metadata === void 0 ? void 0 : metadata.sessionExpiryTimeoutMs;
-            this.sweepTimeoutMs =
-                (_b = metadata === null || metadata === void 0 ? void 0 : metadata.sweepTimeoutMs) !== null && _b !== void 0 ? _b : computeSweepTimeout(this.sessionExpiryTimeoutMs); // Backfill old documents that didn't persist this
-            this.persistedGcFeatureMatrix = metadata === null || metadata === void 0 ? void 0 : metadata.gcFeatureMatrix;
-        }
-        else {
-            // Sweep should not be enabled without enabling GC mark phase. We could silently disable sweep in this
-            // scenario but explicitly failing makes it clearer and promotes correct usage.
-            if (this.gcOptions.sweepAllowed && this.gcOptions.gcAllowed === false) {
-                throw new UsageError("GC sweep phase cannot be enabled without enabling GC mark phase");
-            }
-            // This Test Override only applies for new containers
-            const testOverrideSweepTimeoutMs = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.SweepTimeoutMs");
-            // For new documents, GC is enabled by default. It can be explicitly disabled by setting the gcAllowed
-            // flag in GC options to false.
-            this.gcEnabled = this.gcOptions.gcAllowed !== false;
-            // The sweep phase has to be explicitly enabled by setting the sweepAllowed flag in GC options to true.
-            this.sweepEnabled = this.gcOptions.sweepAllowed === true;
-            // Set the Session Expiry only if the flag is enabled and GC is enabled.
-            if (this.mc.config.getBoolean(runSessionExpiryKey) && this.gcEnabled) {
-                this.sessionExpiryTimeoutMs =
-                    (_c = this.gcOptions.sessionExpiryTimeoutMs) !== null && _c !== void 0 ? _c : defaultSessionExpiryDurationMs;
-            }
-            this.sweepTimeoutMs =
-                testOverrideSweepTimeoutMs !== null && testOverrideSweepTimeoutMs !== void 0 ? testOverrideSweepTimeoutMs : computeSweepTimeout(this.sessionExpiryTimeoutMs);
-            if (this.gcOptions[gcTombstoneGenerationOptionName] !== undefined) {
-                this.persistedGcFeatureMatrix = {
-                    tombstoneGeneration: this.gcOptions[gcTombstoneGenerationOptionName],
-                };
-            }
-        }
+        this.configs = generateGCConfigs(this.mc, createParams);
         // If session expiry is enabled, we need to close the container when the session expiry timeout expires.
-        if (this.sessionExpiryTimeoutMs !== undefined) {
+        if (this.configs.sessionExpiryTimeoutMs !== undefined) {
             // If Test Override config is set, override Session Expiry timeout.
             const overrideSessionExpiryTimeoutMs = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.SessionExpiryMs");
-            const timeoutMs = overrideSessionExpiryTimeoutMs !== null && overrideSessionExpiryTimeoutMs !== void 0 ? overrideSessionExpiryTimeoutMs : this.sessionExpiryTimeoutMs;
+            const timeoutMs = overrideSessionExpiryTimeoutMs !== null && overrideSessionExpiryTimeoutMs !== void 0 ? overrideSessionExpiryTimeoutMs : this.configs.sessionExpiryTimeoutMs;
             this.sessionExpiryTimer = new Timer(timeoutMs, () => {
                 this.runtime.closeFn(new ClientSessionExpiredError(`Client session expired.`, timeoutMs));
             });
             this.sessionExpiryTimer.start();
         }
-        /**
-         * Whether GC should run or not. The following conditions have to be met to run sweep:
-         *
-         * 1. GC should be enabled for this container.
-         *
-         * 2. GC should not be disabled via disableGC GC option.
-         *
-         * These conditions can be overridden via runGCKey feature flag.
-         */
-        this.shouldRunGC =
-            (_d = this.mc.config.getBoolean(runGCKey)) !== null && _d !== void 0 ? _d : 
-            // GC must be enabled for the document.
-            (this.gcEnabled &&
-                // GC must not be disabled via GC options.
-                !this.gcOptions.disableGC);
-        /**
-         * 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. Sweep timeout should be available. Without this, we wouldn't know when an object should be deleted.
-         * 3. The driver must implement the policy limiting the age of snapshots used for loading. Otherwise
-         * the Sweep Timeout calculation is not valid. We use the persisted value to ensure consistency over time.
-         * 4. Sweep should be enabled for this container (this.sweepEnabled). This can be overridden via runSweep
-         * feature flag.
-         */
-        this.shouldRunSweep =
-            this.shouldRunGC &&
-                this.sweepTimeoutMs !== undefined &&
-                ((_e = this.mc.config.getBoolean(runSweepKey)) !== null && _e !== void 0 ? _e : this.sweepEnabled);
-        this.trackGCState = this.mc.config.getBoolean(trackGCStateKey) === true;
-        // Override inactive timeout if test config or gc options to override it is set.
-        this.inactiveTimeoutMs =
-            (_g = (_f = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _f !== void 0 ? _f : this.gcOptions.inactiveTimeoutMs) !== null && _g !== void 0 ? _g : 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 UsageError("inactive timeout should not be greater than the sweep timeout");
-        }
-        // Whether we are running in test mode. In this mode, unreferenced nodes are immediately deleted.
-        this.testMode =
-            (_h = this.mc.config.getBoolean(gcTestModeKey)) !== null && _h !== void 0 ? _h : this.gcOptions.runGCInTestMode === true;
-        // Whether we are running in tombstone mode. This is enabled by default if sweep won't run. It can be disabled
-        // via feature flags.
-        this.tombstoneMode =
-            !this.shouldRunSweep && this.mc.config.getBoolean(disableTombstoneKey) !== true;
-        this.summaryStateTracker = new GCSummaryStateTracker(this.shouldRunGC, this.trackGCState, this.tombstoneMode, this.mc, (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[gcTreeKey]) !== undefined /* wasGCRunInBaseSnapshot */, gcVersionInBaseSnapshot);
+        this.summaryStateTracker = new GCSummaryStateTracker(this.shouldRunGC, this.configs.tombstoneMode, this.mc, (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[gcTreeKey]) !== undefined /* wasGCRunInBaseSnapshot */, this.configs.gcVersionInBaseSnapshot);
         // 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(async () => {
-            var _a;
             if (baseSnapshot === undefined) {
                 return undefined;
             }
@@ -209,52 +102,14 @@ export class GarbageCollector {
                 if (gcSnapshotTree !== undefined) {
                     return getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob);
                 }
-                // back-compat - Older documents will have the GC blobs in each data store's summary tree. Get them and
-                // consolidate into IGarbageCollectionState format.
-                // Add a node for the root node that is not present in older snapshot format.
-                const gcState = {
-                    gcNodes: { "/": { outboundRoutes: [] } },
-                };
-                const dataStoreSnapshotTree = getSummaryForDatastores(baseSnapshot, metadata);
-                assert(dataStoreSnapshotTree !== undefined, 0x2a8 /* "Expected data store snapshot tree in base snapshot" */);
-                for (const [dsId, dsSnapshotTree] of Object.entries(dataStoreSnapshotTree.trees)) {
-                    const blobId = dsSnapshotTree.blobs[gcTreeKey];
-                    if (blobId === undefined) {
-                        continue;
-                    }
-                    const gcSummaryDetails = await readAndParseBlob(blobId);
-                    // If there are no nodes for this data store, skip it.
-                    if (((_a = gcSummaryDetails.gcData) === null || _a === void 0 ? void 0 : _a.gcNodes) === undefined) {
-                        continue;
-                    }
-                    const dsRootId = `/${dsId}`;
-                    // Since we used to write GC data at data store level, we won't have an entry for the root ("/").
-                    // Construct that entry by adding root data store ids to its outbound routes.
-                    const initialSnapshotDetails = await readAndParseBlob(dsSnapshotTree.blobs[dataStoreAttributesBlobName]);
-                    if (initialSnapshotDetails.isRootDataStore) {
-                        gcState.gcNodes["/"].outboundRoutes.push(dsRootId);
-                    }
-                    for (const [id, outboundRoutes] of Object.entries(gcSummaryDetails.gcData.gcNodes)) {
-                        // Prefix the data store id to the GC node ids to make them relative to the root from being
-                        // relative to the data store. Similar to how its done in DataStore::getGCData.
-                        const rootId = id === "/" ? dsRootId : `${dsRootId}${id}`;
-                        gcState.gcNodes[rootId] = {
-                            outboundRoutes: Array.from(outboundRoutes),
-                        };
-                    }
-                    assert(gcState.gcNodes[dsRootId] !== undefined, 0x2a9 /* GC nodes for data store not in GC blob */);
-                    gcState.gcNodes[dsRootId].unreferencedTimestampMs =
-                        gcSummaryDetails.unrefTimestamp;
-                }
-                // If there is only one node (root node just added above), either GC is disabled or we are loading from
-                // the first summary generated by detached container. In both cases, GC was not run - return undefined.
-                return Object.keys(gcState.gcNodes).length === 1
-                    ? undefined
-                    : { gcState, tombstones: undefined, deletedNodes: undefined };
+                // back-compat - Older documents will have the GC blobs in each data store's snapshot tree.
+                return getSnapshotDataFromOldSnapshotFormat(baseSnapshot, createParams.metadata, readAndParseBlob);
             }
             catch (error) {
                 const dpe = DataProcessingError.wrapIfUnrecognized(error, "FailedToInitializeGC");
-                dpe.addTelemetryProperties({ gcConfigs: JSON.stringify(this.configs) });
+                dpe.addTelemetryProperties({
+                    gcConfigs: JSON.stringify(this.configs),
+                });
                 throw dpe;
             }
         });
@@ -316,15 +171,15 @@ export class GarbageCollector {
             this.mc.logger.sendTelemetryEvent({
                 eventName: "GarbageCollectorLoaded",
                 gcConfigs: JSON.stringify(this.configs),
+                gcOptions: JSON.stringify(createParams.gcOptions),
             });
         }
     }
     static create(createParams) {
         return new GarbageCollector(createParams);
     }
-    /** Returns a list of all the configurations for garbage collection. */
-    get configs() {
-        return Object.assign({ gcEnabled: this.gcEnabled, sweepEnabled: this.sweepEnabled, runGC: this.shouldRunGC, runSweep: this.shouldRunSweep, testMode: this.testMode, tombstoneMode: this.tombstoneMode, sessionExpiry: this.sessionExpiryTimeoutMs, sweepTimeout: this.sweepTimeoutMs, inactiveTimeout: this.inactiveTimeoutMs, trackGCState: this.trackGCState }, this.gcOptions);
+    get shouldRunGC() {
+        return this.configs.shouldRunGC;
     }
     get summaryStateNeedsReset() {
         return this.summaryStateTracker.doesSummaryStateNeedReset();
@@ -351,7 +206,7 @@ export class GarbageCollector {
         }
         // If running in tombstone mode, initialize the tombstone state from the snapshot. Also, notify the runtime of
         // tombstone routes.
-        if (this.tombstoneMode && baseSnapshotData.tombstones !== undefined) {
+        if (this.configs.tombstoneMode && baseSnapshotData.tombstones !== undefined) {
             // Create a copy since we are writing from a source we don't control
             this.tombstones = Array.from(baseSnapshotData.tombstones);
             this.runtime.updateTombstonedRoutes(this.tombstones);
@@ -386,7 +241,7 @@ export class GarbageCollector {
         // tombstones.
         // If this call is because we are refreshing from a snapshot due to an ack, it is likely that the GC state
         // in the snapshot is newer than this client's. And so, the deleted / tombstone nodes need to be updated.
-        if (this.shouldRunSweep) {
+        if (this.configs.shouldRunSweep) {
             const snapshotDeletedNodes = (snapshotData === null || snapshotData === void 0 ? void 0 : snapshotData.deletedNodes)
                 ? new Set(snapshotData.deletedNodes)
                 : undefined;
@@ -404,7 +259,7 @@ export class GarbageCollector {
                 }
             }
         }
-        else if (this.tombstoneMode) {
+        else if (this.configs.tombstoneMode) {
             // The snapshot may contain more or fewer tombstone nodes than this client. Update tombstone state and
             // notify the runtime to update its state as well.
             this.tombstones = (snapshotData === null || snapshotData === void 0 ? void 0 : snapshotData.tombstones) ? Array.from(snapshotData.tombstones) : [];
@@ -422,7 +277,7 @@ export class GarbageCollector {
         const gcNodes = {};
         for (const [nodeId, nodeData] of Object.entries(snapshotData.gcState.gcNodes)) {
             if (nodeData.unreferencedTimestampMs !== undefined) {
-                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs, this.sweepTimeoutMs));
+                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.configs.inactiveTimeoutMs, currentReferenceTimestampMs, this.configs.sweepTimeoutMs));
             }
             gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
         }
@@ -448,7 +303,7 @@ export class GarbageCollector {
          * Ideally, this initialization should only be done for summarizer client. However, we are currently rolling out
          * sweep in phases and we want to track when inactive and sweep ready objects are used in any client.
          */
-        if (this.activeConnection() && this.shouldRunGC) {
+        if (this.activeConnection() && this.configs.shouldRunGC) {
             this.initializeGCStateFromBaseSnapshotP.catch((error) => { });
         }
     }
@@ -458,7 +313,7 @@ export class GarbageCollector {
      */
     async collectGarbage(options, telemetryContext) {
         var _a;
-        const fullGC = (_a = options.fullGC) !== null && _a !== void 0 ? _a : (this.gcOptions.runFullGC === true ||
+        const fullGC = (_a = options.fullGC) !== null && _a !== void 0 ? _a : (this.configs.runFullGC === true ||
             this.summaryStateTracker.doesSummaryStateNeedReset());
         const logger = options.logger
             ? ChildLogger.create(options.logger, undefined, {
@@ -515,15 +370,15 @@ export class GarbageCollector {
         // delete these objects here instead.
         this.logSweepEvents(logger, currentReferenceTimestampMs);
         let updatedGCData = gcData;
-        if (this.shouldRunSweep) {
+        if (this.configs.shouldRunSweep) {
             updatedGCData = this.runSweepPhase(sweepReadyNodes, gcData);
         }
-        else if (this.testMode) {
+        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.
             this.runtime.updateUnusedRoutes(gcResult.deletedNodeIds);
         }
-        else if (this.tombstoneMode) {
+        else 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.
@@ -544,7 +399,7 @@ export class GarbageCollector {
      */
     summarize(fullTree, trackState, telemetryContext) {
         var _a;
-        if (!this.shouldRunGC || this.gcDataFromLastRun === undefined) {
+        if (!this.configs.shouldRunGC || this.gcDataFromLastRun === undefined) {
             return;
         }
         const gcState = { gcNodes: {} };
@@ -562,11 +417,11 @@ export class GarbageCollector {
              * If GC is enabled, the GC data is written using the current GC version and that is the gcFeature that goes
              * into the metadata blob. If GC is disabled, the gcFeature is 0.
              */
-            gcFeature: this.gcEnabled ? this.summaryStateTracker.currentGCVersion : 0,
-            gcFeatureMatrix: this.persistedGcFeatureMatrix,
-            sessionExpiryTimeoutMs: this.sessionExpiryTimeoutMs,
-            sweepEnabled: this.sweepEnabled,
-            sweepTimeoutMs: this.sweepTimeoutMs,
+            gcFeature: this.configs.gcEnabled ? this.summaryStateTracker.currentGCVersion : 0,
+            gcFeatureMatrix: this.configs.persistedGcFeatureMatrix,
+            sessionExpiryTimeoutMs: this.configs.sessionExpiryTimeoutMs,
+            sweepEnabled: this.configs.sweepEnabled,
+            sweepTimeoutMs: this.configs.sweepTimeoutMs,
         };
     }
     /**
@@ -592,7 +447,7 @@ export class GarbageCollector {
                 throw DataProcessingError.create("No reference timestamp when updating GC state from snapshot", "refreshLatestSummary", undefined, {
                     proposalHandle,
                     summaryRefSeq: result.summaryRefSeq,
-                    details: JSON.stringify(this.configs),
+                    gcConfigs: JSON.stringify(this.configs),
                 });
             }
             this.updateStateFromSnapshotData(latestSnapshotData, currentReferenceTimestampMs);
@@ -607,7 +462,7 @@ export class GarbageCollector {
      * @param requestHeaders - If the node was loaded via request path, the headers in the request.
      */
     nodeUpdated(nodePath, reason, timestampMs, packagePath, requestHeaders) {
-        if (!this.shouldRunGC) {
+        if (!this.configs.shouldRunGC) {
             return;
         }
         const nodeStateTracker = this.unreferencedNodesState.get(nodePath);
@@ -624,7 +479,7 @@ export class GarbageCollector {
      */
     addedOutboundReference(fromNodePath, toNodePath) {
         var _a;
-        if (!this.shouldRunGC) {
+        if (!this.configs.shouldRunGC) {
             return;
         }
         const outboundRoutes = (_a = this.newReferencesSinceLastRun.get(fromNodePath)) !== null && _a !== void 0 ? _a : [];
@@ -701,7 +556,7 @@ export 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.sweepTimeoutMs));
+                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(currentReferenceTimestampMs, this.configs.inactiveTimeoutMs, currentReferenceTimestampMs, this.configs.sweepTimeoutMs));
             }
             else {
                 nodeStateTracker.updateTracking(currentReferenceTimestampMs);
@@ -936,7 +791,7 @@ export class GarbageCollector {
      */
     logSweepEvents(logger, currentReferenceTimestampMs) {
         if (this.mc.config.getBoolean(disableSweepLogKey) === true ||
-            this.sweepTimeoutMs === undefined) {
+            this.configs.sweepTimeoutMs === undefined) {
             return;
         }
         this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
@@ -958,7 +813,7 @@ export class GarbageCollector {
                 id: nodeId,
                 type: nodeType,
                 age: currentReferenceTimestampMs - nodeStateTracker.unreferencedTimestampMs,
-                timeout: this.sweepTimeoutMs,
+                timeout: this.configs.sweepTimeoutMs,
                 completedGCRuns: this.completedRuns,
                 lastSummaryTime: this.getLastSummaryTimestampMs(),
             });
@@ -988,8 +843,8 @@ export class GarbageCollector {
         }
         this.loggedUnreferencedEvents.add(uniqueEventId);
         const propsToLog = Object.assign(Object.assign({ 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() }, this.createContainerMetadata), { viaHandle: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[RuntimeHeaders.viaHandle], fromId: fromNodeId });
+                ? this.configs.inactiveTimeoutMs
+                : this.configs.sweepTimeoutMs, completedGCRuns: this.completedRuns, lastSummaryTime: this.getLastSummaryTimestampMs() }, this.createContainerMetadata), { viaHandle: requestHeaders === null || requestHeaders === void 0 ? void 0 : 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.