@fluidframework/container-runtime 0.59.4001 → 1.1.0-75972

package/lib/garbageCollection.js

@@ -11,7 +11,6 @@ import { mergeStats, SummaryTreeBuilder, } from "@fluidframework/runtime-utils";
 import { ChildLogger, loggerToMonitoringContext, PerformanceEvent, TelemetryDataTag, } from "@fluidframework/telemetry-utils";
 import { RuntimeHeaders } from "./containerRuntime";
 import { getSummaryForDatastores } from "./dataStores";
-import { pkgVersion } from "./packageVersion";
 import { getGCVersion, metadataBlobName, dataStoreAttributesBlobName, } from "./summaryFormat";
 /** This is the current version of garbage collection. */
 const GCVersion = 1;
@@ -31,12 +30,8 @@ const writeAtRootKey = "Fluid.GarbageCollection.WriteDataAtRoot";
 export const runSessionExpiryKey = "Fluid.GarbageCollection.RunSessionExpiry";
 // Feature gate key to disable expiring session after a set period of time, even if expiry value is present
 export const disableSessionExpiryKey = "Fluid.GarbageCollection.DisableSessionExpiry";
-// Feature gate key to log error messages if GC reference validation fails.
-export const logUnknownOutboundReferencesKey = "Fluid.GarbageCollection.LogUnknownOutboundReferences";
 // Feature gate key to write the gc blob as a handle if the data is the same.
 export const trackGCStateKey = "Fluid.GarbageCollection.TrackGCState";
-// Feature gate key to limit which versions can write the gc blob as a handle if the data is the same.
-export const trackGCStateMinimumVersionKey = "Fluid.GarbageCollection.TrackGCState.MinVersion";
 const defaultInactiveTimeoutMs = 7 * 24 * 60 * 60 * 1000; // 7 days
 export const defaultSessionExpiryDurationMs = 30 * 24 * 60 * 60 * 1000; // 30 days
 /** The types of GC nodes in the GC reference graph. */
@@ -114,21 +109,12 @@ class UnreferencedStateTracker {
  *  NodeId = "dds1"     NodeId = "dds2"
  */
 export class GarbageCollector {
-    constructor(runtime, gcOptions, 
-    /** For a given node path, returns the node's package path. */
-    getNodePackagePath, 
-    /** Returns the timestamp of the last summary generated for this container. */
-    getLastSummaryTimestampMs, baseSnapshot, readAndParseBlob, baseLogger, existing, metadata, isSummarizerClient = true) {
+    constructor(createParams) {
         var _a, _b, _c, _d, _e, _f, _g;
-        this.runtime = runtime;
-        this.gcOptions = gcOptions;
-        this.getNodePackagePath = getNodePackagePath;
-        this.getLastSummaryTimestampMs = getLastSummaryTimestampMs;
-        this.isSummarizerClient = isSummarizerClient;
         /**
          * Tells whether the GC data should be written to the root of the summary tree.
          */
-        this._writeDataAtRoot = false;
+        this._writeDataAtRoot = true;
         /**
          * Tells whether the initial GC state needs to be reset. This can happen under 2 conditions:
          * 1. The base snapshot contains GC state but GC is disabled. This will happen the first time GC is disabled after
@@ -154,7 +140,15 @@ export class GarbageCollector {
         this.pendingEventsQueue = [];
         // The number of times GC has successfully completed on this instance of GarbageCollector.
         this.completedRuns = 0;
-        this.mc = loggerToMonitoringContext(ChildLogger.create(baseLogger, "GarbageCollector", { all: { completedGCRuns: () => this.completedRuns } }));
+        this.runtime = createParams.runtime;
+        this.isSummarizerClient = createParams.isSummarizerClient;
+        this.gcOptions = createParams.gcOptions;
+        this.getNodePackagePath = createParams.getNodePackagePath;
+        this.getLastSummaryTimestampMs = createParams.getLastSummaryTimestampMs;
+        const baseSnapshot = createParams.baseSnapshot;
+        const metadata = createParams.metadata;
+        const readAndParseBlob = createParams.readAndParseBlob;
+        this.mc = loggerToMonitoringContext(ChildLogger.create(createParams.baseLogger, "GarbageCollector", { all: { completedGCRuns: () => this.completedRuns } }));
         let prevSummaryGCVersion;
         /**
          * The following GC state is enabled during container creation and cannot be changed throughout its lifetime:
@@ -163,7 +157,7 @@ export class GarbageCollector {
          * 3. Whether GC session expiry is enabled or not.
          * For existing containers, we get this information from the metadata blob of its summary.
          */
-        if (existing) {
+        if (createParams.existing) {
             prevSummaryGCVersion = 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.
@@ -174,12 +168,14 @@ export class GarbageCollector {
         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 (gcOptions.sweepAllowed && !gcOptions.gcAllowed) {
+            if (this.gcOptions.sweepAllowed && this.gcOptions.gcAllowed === false) {
                 throw new UsageError("GC sweep phase cannot be enabled without enabling GC mark phase");
             }
-            // For new documents, GC has to be explicitly enabled via the flags in GC options.
-            this.gcEnabled = gcOptions.gcAllowed === true;
-            this.sweepEnabled = gcOptions.sweepAllowed === true;
+            // 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 or the test option is set.
             if (this.mc.config.getBoolean(runSessionExpiryKey) && this.gcEnabled) {
                 this.sessionExpiryTimeoutMs = defaultSessionExpiryDurationMs;
@@ -213,10 +209,8 @@ export class GarbageCollector {
         // GC must be enabled for the document.
         this.gcEnabled
             // GC must not be disabled via GC options.
-            && !gcOptions.disableGC);
-        const minimumVersion = this.mc.config.getString(trackGCStateMinimumVersionKey);
-        const shouldTrackStateForVersion = meetsMinimumVersionRequirement(pkgVersion, minimumVersion);
-        this.trackGCState = this.mc.config.getBoolean(trackGCStateKey) === true && shouldTrackStateForVersion;
+            && !this.gcOptions.disableGC);
+        this.trackGCState = this.mc.config.getBoolean(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).
@@ -228,19 +222,15 @@ export class GarbageCollector {
         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;
         // 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 : gcOptions.runGCInTestMode === true;
-        /**
-         * Enable resetting initial state once the following issue is resolved:
-         * https://github.com/microsoft/FluidFramework/issues/8878.
-         * Currently, the GC tree is not written at root, so we don't know if the base snapshot contains GC tree or not.
-         */
-        // The GC state needs to be reset if the base snapshot contains GC tree and GC is disabled or it doesn't contain
-        // GC tree and GC is enabled.
-        // const gcTreePresent = baseSnapshot?.trees[gcTreeKey] !== undefined;
-        // this.initialStateNeedsReset = gcTreePresent ? !this.shouldRunGC : this.shouldRunGC;
-        // If `writeDataAtRoot` setting is true, write the GC data into the root of the summary tree. We do this so that
-        // the roll out can be staged. Once its rolled out everywhere, we will start writing at root by default.
-        this._writeDataAtRoot = (_g = this.mc.config.getBoolean(writeAtRootKey)) !== null && _g !== void 0 ? _g : this.gcOptions.writeDataAtRoot === true;
+        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.
+        this._writeDataAtRoot = (_g = this.mc.config.getBoolean(writeAtRootKey)) !== null && _g !== void 0 ? _g : true;
+        if (this._writeDataAtRoot) {
+            // The GC state needs to be reset if the base snapshot contains GC tree and GC is disabled or it doesn't
+            // contain GC tree and GC is enabled.
+            const gcTreePresent = (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[gcTreeKey]) !== undefined;
+            this.initialStateNeedsReset = gcTreePresent !== this.shouldRunGC;
+        }
         // Get the GC state from the GC blob in the base snapshot. Use LazyPromise because we only want to do
         // this once since it involves fetching blobs from storage which is expensive.
         const baseSummaryStateP = new LazyPromise(async () => {
@@ -329,7 +319,7 @@ export class GarbageCollector {
             // Run GC on the nodes in the base summary to get the routes used in each node in the container.
             // This is an optimization for space (vs performance) wherein we don't need to store the used routes of
             // each node in the summary.
-            const usedRoutes = runGarbageCollection(gcNodes, ["/"], this.mc.logger).referencedNodeIds;
+            const usedRoutes = runGarbageCollection(gcNodes, ["/"]).referencedNodeIds;
             const baseGCDetailsMap = unpackChildNodesGCDetails({ gcData: { gcNodes }, usedRoutes });
             // Currently, the nodes may write the GC data. So, we need to update it's base GC details with the
             // unreferenced timestamp. Once we start writing the GC data here, we won't need to do this anymore.
@@ -345,7 +335,7 @@ export 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 }, 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 }, this.gcOptions));
         if (this.isSummarizerClient) {
             this.mc.logger.sendTelemetryEvent({
                 eventName: "GarbageCollectorLoaded",
@@ -361,8 +351,8 @@ export class GarbageCollector {
             });
         }
     }
-    static create(provider, gcOptions, getNodePackagePath, getLastSummaryTimestampMs, baseSnapshot, readAndParseBlob, baseLogger, existing, metadata, isSummarizerClient) {
-        return new GarbageCollector(provider, gcOptions, getNodePackagePath, getLastSummaryTimestampMs, baseSnapshot, readAndParseBlob, baseLogger, existing, metadata, isSummarizerClient);
+    static create(createParams) {
+        return new GarbageCollector(createParams);
     }
     /**
      * Tells whether the GC state needs to be reset in the next summary. We need to do this if:
@@ -394,7 +384,7 @@ export class GarbageCollector {
             await this.runtime.updateStateBeforeGC();
             // 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, ["/"], logger);
+            const gcResult = 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.
@@ -421,7 +411,7 @@ export class GarbageCollector {
      * We current write the entire GC state in a single blob. This can be modified later to write multiple
      * blobs. All the blob keys should start with `gcBlobPrefix`.
      */
-    summarize(fullTree, trackState) {
+    summarize(fullTree, trackState, telemetryContext) {
         var _a;
         if (!this.shouldRunGC || this.previousGCDataFromLastRun === undefined) {
             return;
@@ -483,9 +473,6 @@ export class GarbageCollector {
      * latest summary tracked.
      */
     async latestSummaryStateRefreshed(result, readAndParseBlob) {
-        // After a summary is successfully submitted and ack'd by this client, the GC state should have been reset in
-        // the summary and doesn't need to be reset anymore.
-        this.initialStateNeedsReset = false;
         if (!this.shouldRunGC || !result.latestSummaryUpdated) {
             return;
         }
@@ -493,6 +480,7 @@ export class GarbageCollector {
         // Basically, it was written in the current GC version.
         if (result.wasSummaryTracked) {
             this.latestSummaryGCVersion = this.currentGCVersion;
+            this.initialStateNeedsReset = false;
             if (this.trackGCState) {
                 this.latestSerializedSummaryState = this.pendingSerializedSummaryState;
                 this.pendingSerializedSummaryState = undefined;
@@ -615,10 +603,7 @@ export class GarbageCollector {
         }
         // Find any references that haven't been identified correctly.
         const missingExplicitReferences = this.findMissingExplicitReferences(currentGCData, this.previousGCDataFromLastRun, this.newReferencesSinceLastRun);
-        // The following log will be enabled once this issue is resolved:
-        // https://github.com/microsoft/FluidFramework/issues/8878.
-        if (this.mc.config.getBoolean(logUnknownOutboundReferencesKey) === true
-            && missingExplicitReferences.length > 0) {
+        if (this.writeDataAtRoot && missingExplicitReferences.length > 0) {
             missingExplicitReferences.forEach((missingExplicitReference) => {
                 const event = {
                     eventName: "gcUnknownOutboundReferences",
@@ -662,7 +647,7 @@ export class GarbageCollector {
          * unreferenced, stop tracking them and remove from unreferenced list.
          * Some of these nodes may be unreferenced now and if so, the current run will add unreferenced state for them.
          */
-        const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, ["/"], logger);
+        const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, ["/"]);
         for (const nodeId of gcResult.referencedNodeIds) {
             const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
             if (nodeStateTracker !== undefined) {
@@ -742,11 +727,10 @@ export class GarbageCollector {
         };
         const updateNodeStats = (nodeId, referenced) => {
             gcStats.nodeCount++;
-            /**
-             * `this.unreferencedNodesState` has the previous unreferenced state of all nodes. `referenced` flag passed
-             * here is current state of the give node. Check if the reference state of the changed.
-             */
-            const stateUpdated = this.unreferencedNodesState.has(nodeId) ? referenced : !referenced;
+            // If there is no previous GC data, every node's state is generated and is considered as updated.
+            // Otherwise, find out if any node went from referenced to unreferenced or vice-versa.
+            const stateUpdated = this.previousGCDataFromLastRun === undefined ||
+                this.unreferencedNodesState.has(nodeId) === referenced;
             if (stateUpdated) {
                 gcStats.updatedNodeCount++;
             }
@@ -822,7 +806,7 @@ export class GarbageCollector {
             // 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: TelemetryDataTag.PackageData } }));
+                this.mc.logger.sendErrorEvent(Object.assign(Object.assign({}, event), { pkg: { value: pkg.join("/"), tag: TelemetryDataTag.PackageData } }));
             }
             else {
                 this.pendingEventsQueue.push(event);
@@ -881,62 +865,4 @@ function setLongTimeout(timeoutMs, timeoutFn, setTimerFn) {
     }
     setTimerFn(timer);
 }
-/**
- * meetsMinimumVersionRequirement is used determining if a feature version should be run. This is similar to feature
- * flags. The advantage of this is that if we ship a bug in version 0.1.1 and fix it in version 0.2.1. We can keep this
- * feature disabled for version 0.1.1 and enabled for 0.2.1. Older versions will run without the feature and new
- * versions will run with the feature.
- * @param currentVersion - the total time the timeout needs to last in ms
- * @param minimumVersion - the function to execute when the timer ends
- */
-function meetsMinimumVersionRequirement(currentVersion, minimumVersion) {
-    return minimumVersion === undefined || semverCompare(currentVersion, minimumVersion) >= 0;
-}
-/**
- * Compare semver versions.
- * @param currentVersion - assumed to be any valid semver version
- * @param minimumVersion - must be [major].[minor].[patch], where major, minor, and patch are all numbers
- *  as it complicates the algorithm if we allow comparisons against minimum pre-release versions.
- * @returns
- *  0 if the currentVersion equals the minimumVersion
- *  1 if the currentVersion is greater than the minimumVersion
- *  -1 if the minimumVersion is greater than the currentVersion
- */
-export function semverCompare(currentVersion, minimumVersion) {
-    const minimumValues = minimumVersion.split(".").map((value) => {
-        assert(isNaN(+value) === false, 0x2fa /* Expected real numbers in minimum version! */);
-        return Number.parseInt(value, 10);
-    });
-    assert(minimumValues.length === 3, 0x2fb /* Expected minimumVersion to be [major].[minor].[patch] */);
-    const [minMajor, minMinor, minPatch] = minimumValues;
-    const currentValuesString = currentVersion.split(/\W/);
-    assert(currentValuesString.length >= 3, 0x2fc /* Expected version to match semver rules! */);
-    const currentValues = currentValuesString.slice(0, 3).map((value) => {
-        assert(isNaN(+value) === false, 0x2fd /* Expected real numbers in minimum version! */);
-        return Number.parseInt(value, 10);
-    });
-    const [cMajor, cMinor, cPatch] = currentValues;
-    if (cMajor > minMajor) {
-        return 1;
-    }
-    else if (minMajor > cMajor) {
-        return -1;
-    }
-    if (cMinor > minMinor) {
-        return 1;
-    }
-    else if (minMinor > cMinor) {
-        return -1;
-    }
-    if (cPatch > minPatch) {
-        return 1;
-    }
-    else if (minPatch > cPatch) {
-        return -1;
-    }
-    if (currentValuesString.length === 3) {
-        return 0;
-    }
-    return -1;
-}
 //# sourceMappingURL=garbageCollection.js.map