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

package/lib/gc/garbageCollection.js

@@ -2,29 +2,18 @@
  * 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;
-};
-import { assert, LazyPromise, Timer } from "@fluidframework/common-utils";
+import { LazyPromise, Timer } from "@fluidframework/common-utils";
 import { ClientSessionExpiredError, DataProcessingError } from "@fluidframework/container-utils";
 import { gcTreeKey, } from "@fluidframework/runtime-definitions";
-import { packagePathToTelemetryProperty } from "@fluidframework/runtime-utils";
-import { ChildLogger, generateStack, loggerToMonitoringContext, PerformanceEvent, TelemetryDataTag, } from "@fluidframework/telemetry-utils";
+import { ChildLogger, loggerToMonitoringContext, PerformanceEvent, } from "@fluidframework/telemetry-utils";
 import { RuntimeHeaders } from "../containerRuntime";
 import { generateGCConfigs } from "./gcConfigs";
-import { disableSweepLogKey, GCNodeType, UnreferencedState, } from "./gcDefinitions";
-import { cloneGCData, concatGarbageCollectionData, getGCDataFromSnapshot, sendGCUnexpectedUsageEvent, } from "./gcHelpers";
+import { GCNodeType, UnreferencedState, } from "./gcDefinitions";
+import { cloneGCData, concatGarbageCollectionData, getGCDataFromSnapshot } from "./gcHelpers";
 import { runGarbageCollection } from "./gcReferenceGraphAlgorithm";
 import { GCSummaryStateTracker } from "./gcSummaryStateTracker";
 import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";
+import { GCTelemetryTracker } from "./gcTelemetry";
 /**
  * The garbage collector for the container runtime. It consolidates the garbage collection functionality and maintains
  * its state across summaries.
@@ -58,16 +47,10 @@ export class GarbageCollector {
         this.deletedNodes = new Set();
         // Map of node ids to their unreferenced state tracker.
         this.unreferencedNodesState = new Map();
-        // 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.
-        this.loggedUnreferencedEvents = new Set();
-        // Queue for unreferenced events that should be logged the next time GC runs.
-        this.pendingEventsQueue = [];
         // The number of times GC has successfully completed on this instance of GarbageCollector.
         this.completedRuns = 0;
         this.runtime = createParams.runtime;
         this.isSummarizerClient = createParams.isSummarizerClient;
-        this.createContainerMetadata = createParams.createContainerMetadata;
         this.getNodePackagePath = createParams.getNodePackagePath;
         this.getLastSummaryTimestampMs = createParams.getLastSummaryTimestampMs;
         this.activeConnection = createParams.activeConnection;
@@ -88,6 +71,7 @@ export class GarbageCollector {
             this.sessionExpiryTimer.start();
         }
         this.summaryStateTracker = new GCSummaryStateTracker(this.configs, (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[gcTreeKey]) !== undefined /* wasGCRunInBaseSnapshot */);
+        this.telemetryTracker = new GCTelemetryTracker(this.mc, this.configs, this.isSummarizerClient, this.runtime.gcTombstoneEnforcementAllowed, createParams.createContainerMetadata, (nodeId) => this.runtime.getNodeType(nodeId), (nodeId) => 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(async () => {
@@ -376,9 +360,8 @@ export class GarbageCollector {
         // 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, gcResult, currentReferenceTimestampMs, logger);
         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);
+        // Log events for objects that are ready to be deleted by sweep.
+        this.telemetryTracker.logSweepEvents(logger, currentReferenceTimestampMs, this.unreferencedNodesState, this.completedRuns, this.getLastSummaryTimestampMs());
         let updatedGCData = gcData;
         if (this.configs.shouldRunSweep) {
             updatedGCData = this.runSweepPhase(sweepReadyNodes, gcData);
@@ -399,7 +382,7 @@ export class GarbageCollector {
         // 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);
+        await this.telemetryTracker.logPendingEvents(logger);
         return gcStats;
     }
     /**
@@ -475,10 +458,16 @@ export class GarbageCollector {
         if (!this.configs.shouldRunGC) {
             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({
+            nodeId: nodePath,
+            usageType: reason,
+            currentReferenceTimestampMs: timestampMs !== null && timestampMs !== void 0 ? timestampMs : this.runtime.getCurrentReferenceTimestampMs(),
+            packagePath,
+            completedGCRuns: this.completedRuns,
+            isTombstoned: this.tombstones.includes(nodePath),
+            lastSummaryTime: this.getLastSummaryTimestampMs(),
+            viaHandle: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[RuntimeHeaders.viaHandle],
+        });
     }
     /**
      * Called when an outbound reference is added to a node. This is used to identify all nodes that have been
@@ -495,27 +484,16 @@ export class GarbageCollector {
         const outboundRoutes = (_a = this.newReferencesSinceLastRun.get(fromNodePath)) !== null && _a !== void 0 ? _a : [];
         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({
+            nodeId: toNodePath,
+            usageType: "Revived",
+            currentReferenceTimestampMs: this.runtime.getCurrentReferenceTimestampMs(),
+            packagePath: undefined,
+            completedGCRuns: this.completedRuns,
+            isTombstoned: this.tombstones.includes(toNodePath),
+            lastSummaryTime: this.getLastSummaryTimestampMs(),
+            fromId: fromNodePath,
+        });
     }
     /**
      * Returns whether a node with the given path has been deleted or not. This can be used by the runtime to identify
@@ -637,17 +615,11 @@ export class GarbageCollector {
         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]),
-                });
-            });
-        }
+        /**
+         * 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) {
@@ -693,52 +665,6 @@ export class GarbageCollector {
         ]);
         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
-     */
-    findMissingExplicitReferences(currentGCData, previousGCData, explicitReferences) {
-        assert(previousGCData !== undefined, 0x2b7 /* "Can't validate correctness without GC data from last run" */);
-        const currentGraph = Object.entries(currentGCData.gcNodes);
-        const missingExplicitReferences = [];
-        currentGraph.forEach(([nodeId, currentOutboundRoutes]) => {
-            var _a, _b;
-            const previousRoutes = (_a = previousGCData.gcNodes[nodeId]) !== null && _a !== void 0 ? _a : [];
-            const explicitRoutes = (_b = explicitReferences.get(nodeId)) !== null && _b !== void 0 ? _b : [];
-            const missingExplicitRoutes = [];
-            /**
-             * 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.
@@ -795,128 +721,5 @@ export class GarbageCollector {
         }
         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.
-     */
-    logSweepEvents(logger, currentReferenceTimestampMs) {
-        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.
-     */
-    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 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 = Object.assign(Object.assign({ 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 === 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.
-        // 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(Object.assign(Object.assign({}, 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 = Object.assign(Object.assign({}, 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);
-                }
-            }
-        }
-    }
-    async logUnreferencedEvents(logger) {
-        // 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 } = 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;
-                const event = Object.assign(Object.assign({}, 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 = [];
-    }
 }
 //# sourceMappingURL=garbageCollection.js.map