@fluidframework/container-runtime 2.0.0-dev.4.3.0.159619 → 2.0.0-dev.4.4.0.161516

package/dist/gc/garbageCollection.d.ts

@@ -44,13 +44,11 @@ export declare class GarbageCollector implements IGarbageCollector {
     private readonly baseGCDetailsP;
     private readonly unreferencedNodesState;
     private sessionExpiryTimer;
-    private readonly loggedUnreferencedEvents;
-    private pendingEventsQueue;
     private completedRuns;
     private readonly runtime;
-    private readonly createContainerMetadata;
     private readonly isSummarizerClient;
     private readonly summaryStateTracker;
+    private readonly telemetryTracker;
     /** For a given node path, returns the node's package path. */
     private readonly getNodePackagePath;
     /** Returns the timestamp of the last summary generated for this container. */
@@ -170,35 +168,11 @@ export declare class GarbageCollector implements IGarbageCollector {
      * @returns - a list of all nodes referenced from the last local summary until now.
      */
     private findAllNodesReferencedBetweenGCs;
-    /**
-     * Finds all new references or outbound routes in the current graph that haven't been explicitly notified to GC.
-     * The principle is that every new reference or outbound route must be notified to GC via the
-     * addedOutboundReference method. It it hasn't, its a bug and we want to identify these scenarios.
-     *
-     * In more simple terms:
-     * Missing Explicit References = Current References - Previous References - Explicitly Added References;
-     *
-     * @param currentGCData - The GC data (reference graph) from the current GC run.
-     * @param previousGCData - The GC data (reference graph) from the previous GC run.
-     * @param explicitReferences - New references added explicity between the previous and the current run.
-     * @returns - a list of missing explicit references
-     */
-    private findMissingExplicitReferences;
     /**
      * 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.
      */
     private generateStats;
-    /**
-     * For nodes that are ready to sweep, log an event for now. Until we start running sweep which deletes objects,
-     * this will give us a view into how much deleted content a container has.
-     */
-    private logSweepEvents;
-    /**
-     * Called when an inactive node is used after. Queue up an event that will be logged next time GC runs.
-     */
-    private inactiveNodeUsed;
-    private logUnreferencedEvents;
 }
 //# sourceMappingURL=garbageCollection.d.ts.map

package/dist/gc/garbageCollection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"garbageCollection.d.ts","sourceRoot":"","sources":["../../src/gc/garbageCollection.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"garbageCollection.d.ts","sourceRoot":"","sources":["../../src/gc/garbageCollection.ts"],"names":[],"mappings":"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"}

package/dist/gc/garbageCollection.js

@@ -3,23 +3,11 @@
  * 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 = void 0;
 const common_utils_1 = require("@fluidframework/common-utils");
 const container_utils_1 = require("@fluidframework/container-utils");
 const runtime_definitions_1 = require("@fluidframework/runtime-definitions");
-const runtime_utils_1 = require("@fluidframework/runtime-utils");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 const containerRuntime_1 = require("../containerRuntime");
 const gcConfigs_1 = require("./gcConfigs");
@@ -28,6 +16,7 @@ const gcHelpers_1 = require("./gcHelpers");
 const gcReferenceGraphAlgorithm_1 = require("./gcReferenceGraphAlgorithm");
 const gcSummaryStateTracker_1 = require("./gcSummaryStateTracker");
 const gcUnreferencedStateTracker_1 = require("./gcUnreferencedStateTracker");
+const gcTelemetry_1 = require("./gcTelemetry");
 /**
  * The garbage collector for the container runtime. It consolidates the garbage collection functionality and maintains
  * its state across summaries.
@@ -61,16 +50,10 @@ 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;
@@ -91,6 +74,7 @@ class GarbageCollector {
             this.sessionExpiryTimer.start();
         }
         this.summaryStateTracker = new gcSummaryStateTracker_1.GCSummaryStateTracker(this.configs, (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[runtime_definitions_1.gcTreeKey]) !== undefined /* wasGCRunInBaseSnapshot */);
+        this.telemetryTracker = new gcTelemetry_1.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 common_utils_1.LazyPromise(async () => {
@@ -379,9 +363,8 @@ 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);
@@ -402,7 +385,7 @@ 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;
     }
     /**
@@ -478,10 +461,16 @@ class GarbageCollector {
         if (!this.configs.shouldRunGC) {
             return;
         }
-        const nodeStateTracker = this.unreferencedNodesState.get(nodePath);
-        if (nodeStateTracker && nodeStateTracker.state !== gcDefinitions_1.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[containerRuntime_1.RuntimeHeaders.viaHandle],
+        });
     }
     /**
      * Called when an outbound reference is added to a node. This is used to identify all nodes that have been
@@ -498,27 +487,16 @@ 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 !== gcDefinitions_1.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 === gcDefinitions_1.GCNodeType.DataStore) {
-                eventName = "GC_Tombstone_Datastore_Revived";
-            }
-            else if (nodeType === gcDefinitions_1.GCNodeType.Blob) {
-                eventName = "GC_Tombstone_Blob_Revived";
-            }
-            (0, gcHelpers_1.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
@@ -640,17 +618,11 @@ 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) {
@@ -696,52 +668,6 @@ 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) {
-        (0, common_utils_1.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 === gcDefinitions_1.GCNodeType.DataStore || nodeType === gcDefinitions_1.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.
@@ -798,129 +724,6 @@ 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(gcDefinitions_1.disableSweepLogKey) === true ||
-            this.configs.sweepTimeoutMs === undefined) {
-            return;
-        }
-        this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
-            if (nodeStateTracker.state !== gcDefinitions_1.UnreferencedState.SweepReady) {
-                return;
-            }
-            const nodeType = this.runtime.getNodeType(nodeId);
-            if (nodeType !== gcDefinitions_1.GCNodeType.DataStore && nodeType !== gcDefinitions_1.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 === gcDefinitions_1.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 !== gcDefinitions_1.GCNodeType.DataStore && nodeType !== gcDefinitions_1.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 === gcDefinitions_1.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[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.
-        // 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: (0, runtime_utils_1.packagePathToTelemetryProperty)(packagePath), stack: (0, telemetry_utils_1.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 === gcDefinitions_1.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 === gcDefinitions_1.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: telemetry_utils_1.TelemetryDataTag.CodeArtifact }
-                        : undefined, fromPkg: fromPkg
-                        ? { value: fromPkg.join("/"), tag: telemetry_utils_1.TelemetryDataTag.CodeArtifact }
-                        : undefined });
-                if (state === gcDefinitions_1.UnreferencedState.Inactive) {
-                    logger.sendTelemetryEvent(event);
-                }
-                else {
-                    logger.sendErrorEvent(event);
-                }
-            }
-        }
-        this.pendingEventsQueue = [];
-    }
 }
 exports.GarbageCollector = GarbageCollector;
 //# sourceMappingURL=garbageCollection.js.map