@fluidframework/container-runtime 2.0.0-dev-rc.3.0.0.254866 → 2.0.0-dev-rc.5.0.0.263932

package/lib/channelCollection.js

@@ -5,16 +5,16 @@
 import { AttachState } from "@fluidframework/container-definitions";
 import { assert, Lazy, LazyPromise } from "@fluidframework/core-utils/internal";
 import { FluidObjectHandle } from "@fluidframework/datastore/internal";
-import { buildSnapshotTree } from "@fluidframework/driver-utils/internal";
+import { buildSnapshotTree, getSnapshotTree, isInstanceOfISnapshot, } from "@fluidframework/driver-utils/internal";
 import { CreateSummarizerNodeSource, channelsTreeName, } from "@fluidframework/runtime-definitions/internal";
 import { GCDataBuilder, RequestParser, SummaryTreeBuilder, convertSnapshotTreeToSummaryTree, convertSummaryTreeToITree, create404Response, createResponseError, encodeCompactIdToString, isSerializedHandle, processAttachMessageGCData, responseToException, unpackChildNodesUsedRoutes, } from "@fluidframework/runtime-utils/internal";
 import { DataCorruptionError, DataProcessingError, LoggingError, createChildLogger, createChildMonitoringContext, extractSafePropertiesFromMessage, tagCodeArtifacts, } from "@fluidframework/telemetry-utils/internal";
-import { defaultRuntimeHeaderData } from "./containerRuntime.js";
+import { DeletedResponseHeaderKey, defaultRuntimeHeaderData, } from "./containerRuntime.js";
 import { channelToDataStore, isDataStoreAliasMessage, } from "./dataStore.js";
 import { LocalDetachedFluidDataStoreContext, LocalFluidDataStoreContext, RemoteFluidDataStoreContext, createAttributesBlob, } from "./dataStoreContext.js";
 import { DataStoreContexts } from "./dataStoreContexts.js";
 import { FluidDataStoreRegistry } from "./dataStoreRegistry.js";
-import { GCNodeType, detectOutboundRoutesViaDDSKey, trimLeadingAndTrailingSlashes, } from "./gc/index.js";
+import { GCNodeType, detectOutboundRoutesViaDDSKey, urlToGCNodePath, } from "./gc/index.js";
 import { ContainerMessageType } from "./messageTypes.js";
 import { StorageServiceWithAttachBlobs } from "./storageServiceWithAttachBlobs.js";
 import { nonDataStorePaths, rootHasIsolatedChannels, } from "./summary/index.js";
@@ -80,6 +80,7 @@ export function wrapContext(context) {
         getAudience: (...args) => {
             return context.getAudience(...args);
         },
+        // back-compat, to be removed in 2.0
         ensureNoDataModelChanges: (...args) => {
             return context.ensureNoDataModelChanges(...args);
         },
@@ -171,7 +172,8 @@ export class ChannelCollection {
         // Extract stores stored inside the snapshot
         const fluidDataStores = new Map();
         if (baseSnapshot) {
-            for (const [key, value] of Object.entries(baseSnapshot.trees)) {
+            const baseSnapshotTree = getSnapshotTree(baseSnapshot);
+            for (const [key, value] of Object.entries(baseSnapshotTree.trees)) {
                 fluidDataStores.set(key, value);
             }
         }
@@ -185,9 +187,16 @@ export class ChannelCollection {
             }
             // If we have a detached container, then create local data store contexts.
             if (this.parentContext.attachState !== AttachState.Detached) {
+                let snapshotForRemoteFluidDatastoreContext = value;
+                if (isInstanceOfISnapshot(baseSnapshot)) {
+                    snapshotForRemoteFluidDatastoreContext = {
+                        ...baseSnapshot,
+                        snapshotTree: value,
+                    };
+                }
                 dataStoreContext = new RemoteFluidDataStoreContext({
                     id: key,
-                    snapshotTree: value,
+                    snapshot: snapshotForRemoteFluidDatastoreContext,
                     parentContext: this.wrapContextForInnerChannel(key),
                     storage: this.parentContext.storage,
                     scope: this.parentContext.scope,
@@ -286,16 +295,19 @@ export class ChannelCollection {
             throw error;
         }
         const flatAttachBlobs = new Map();
-        let snapshotTree;
+        let snapshot;
         if (attachMessage.snapshot) {
-            snapshotTree = buildSnapshotTree(attachMessage.snapshot.entries, flatAttachBlobs);
+            snapshot = buildSnapshotTree(attachMessage.snapshot.entries, flatAttachBlobs);
+            if (isInstanceOfISnapshot(this.baseSnapshot)) {
+                snapshot = { ...this.baseSnapshot, snapshotTree: snapshot };
+            }
         }
         // Include the type of attach message which is the pkg of the store to be
         // used by RemoteFluidDataStoreContext in case it is not in the snapshot.
         const pkg = [attachMessage.type];
         const remoteFluidDataStoreContext = new RemoteFluidDataStoreContext({
             id: attachMessage.id,
-            snapshotTree,
+            snapshot,
             parentContext: this.wrapContextForInnerChannel(attachMessage.id),
             storage: new StorageServiceWithAttachBlobs(this.parentContext.storage, flatAttachBlobs),
             scope: this.parentContext.scope,
@@ -377,8 +389,8 @@ export class ChannelCollection {
          * If the container is detached, this data store will be part of the summary that makes the container attached.
          */
         if (this.parentContext.attachState !== AttachState.Detached) {
-            localContext.setAttachState(AttachState.Attaching);
             this.submitAttachChannelOp(localContext);
+            localContext.setAttachState(AttachState.Attaching);
         }
         this.contexts.bind(id);
     }
@@ -428,6 +440,7 @@ export class ChannelCollection {
         return this.createContext(this.createDataStoreId(), pkg, LocalFluidDataStoreContext, props, loadingGroupId);
     }
     createContext(id, pkg, contextCtor, createProps, loadingGroupId) {
+        assert(loadingGroupId !== "", 0x974 /* loadingGroupId should not be the empty string */);
         const context = new contextCtor({
             id,
             pkg,
@@ -604,14 +617,20 @@ export class ChannelCollection {
         context.process(message, local, localMessageMetadata);
         // Notify that a GC node for the data store changed. This is used to detect if a deleted data store is
         // being used.
-        this.gcNodeUpdated(`/${address}`, "Changed", message.timestamp, context.isLoaded ? context.packagePath : undefined);
+        this.gcNodeUpdated({
+            node: { type: "DataStore", path: `/${address}` },
+            reason: "Changed",
+            timestampMs: message.timestamp,
+            packagePath: context.isLoaded ? context.packagePath : undefined,
+        });
     }
-    async getDataStore(id, requestHeaderData) {
+    async getDataStore(id, requestHeaderData, originalRequest) {
         const headerData = { ...defaultRuntimeHeaderData, ...requestHeaderData };
-        if (this.checkAndLogIfDeleted(id, this.contexts.get(id), "Requested", "getDataStore", requestHeaderData)) {
+        if (this.checkAndLogIfDeleted(id, this.contexts.get(id), "Requested", "getDataStore", requestHeaderData, originalRequest)) {
             // The requested data store has been deleted by gc. Create a 404 response exception.
-            const request = { url: id };
-            throw responseToException(createResponseError(404, "DataStore was deleted", request), request);
+            throw responseToException(createResponseError(404, "DataStore was deleted", originalRequest, {
+                [DeletedResponseHeaderKey]: true,
+            }), originalRequest);
         }
         const context = await this.contexts.getBoundOrRemoted(id, headerData.wait);
         if (context === undefined) {
@@ -640,21 +659,52 @@ export class ChannelCollection {
      * Checks if the data store has been deleted by GC. If so, log an error.
      * @param id - The data store's id.
      * @param context - The data store context.
+     * @param deletedLogSuffix - Whether it was Changed or Requested (will go into the eventName)
      * @param callSite - The function name this is called from.
      * @param requestHeaderData - The request header information to log if the data store is deleted.
+     * @param originalRequest - The original request (could be for a child of the DataStore)
      * @returns true if the data store is deleted. Otherwise, returns false.
      */
-    checkAndLogIfDeleted(id, context, deletedLogSuffix, callSite, requestHeaderData) {
+    checkAndLogIfDeleted(id, context, deletedLogSuffix, callSite, requestHeaderData, originalRequest) {
         const dataStoreNodePath = `/${id}`;
         if (!this.isDataStoreDeleted(dataStoreNodePath)) {
             return false;
         }
+        const idToLog = originalRequest !== undefined
+            ? urlToGCNodePath(originalRequest.url)
+            : dataStoreNodePath;
+        // Log the package details asynchronously since getInitialSnapshotDetails is async
+        const recentelyDeletedContext = this.contexts.getRecentlyDeletedContext(id);
+        if (recentelyDeletedContext !== undefined) {
+            recentelyDeletedContext
+                .getInitialSnapshotDetails()
+                .then((details) => {
+                return details.pkg.join("/");
+            })
+                .then((pkg) => ({ pkg, error: undefined }), (error) => ({ pkg: undefined, error }))
+                .then(({ pkg, error }) => {
+                this.mc.logger.sendTelemetryEvent({
+                    eventName: `GC_DeletedDataStore_PathInfo`,
+                    ...tagCodeArtifacts({
+                        id: idToLog,
+                        pkg,
+                    }),
+                    callSite,
+                }, error);
+            })
+                .catch(() => { });
+        }
         this.mc.logger.sendErrorEvent({
             eventName: `GC_Deleted_DataStore_${deletedLogSuffix}`,
-            ...tagCodeArtifacts({ id }),
+            ...tagCodeArtifacts({ id: idToLog }),
             callSite,
             headers: JSON.stringify(requestHeaderData),
             exists: context !== undefined,
+            details: {
+                url: originalRequest?.url,
+                headers: JSON.stringify(originalRequest?.headers),
+                aliased: this.aliasedDataStores.has(id),
+            },
         });
         return true;
     }
@@ -763,7 +813,7 @@ export class ChannelCollection {
                     // If this data store is not yet loaded, then there should be no changes in the snapshot from
                     // which it was created as it is detached container. So just use the previous snapshot.
                     assert(!!this.baseSnapshot, 0x166 /* "BaseSnapshot should be there as detached container loaded from snapshot" */);
-                    dataStoreSummary = convertSnapshotTreeToSummaryTree(this.baseSnapshot.trees[key]);
+                    dataStoreSummary = convertSnapshotTreeToSummaryTree(getSnapshotTree(this.baseSnapshot).trees[key]);
                 }
                 builder.addWithStats(key, dataStoreSummary);
             });
@@ -844,6 +894,15 @@ export class ChannelCollection {
     deleteChild(dataStoreId) {
         const dataStoreContext = this.contexts.get(dataStoreId);
         assert(dataStoreContext !== undefined, 0x2d7 /* No data store with specified id */);
+        if (dataStoreContext.isLoaded) {
+            this.mc.logger.sendTelemetryEvent({
+                eventName: "GC_DeletingLoadedDataStore",
+                ...tagCodeArtifacts({
+                    id: dataStoreId,
+                    pkg: dataStoreContext.packagePath.join("/"),
+                }),
+            });
+        }
         dataStoreContext.delete();
         // Delete the contexts of unused data stores.
         this.contexts.delete(dataStoreId);
@@ -970,21 +1029,25 @@ export class ChannelCollection {
         if (typeof request.headers?.[AllowInactiveRequestHeaderKey] === "boolean") {
             headerData.allowInactive = request.headers[AllowInactiveRequestHeaderKey];
         }
-        // We allow Tombstone requests for sub-DataStore objects
+        // We allow Tombstone/Inactive requests for sub-DataStore objects
         if (requestForChild) {
             headerData.allowTombstone = true;
+            headerData.allowInactive = true;
         }
         await this.waitIfPendingAlias(id);
         const internalId = this.internalId(id);
-        const dataStoreContext = await this.getDataStore(internalId, headerData);
-        // Remove query params, leading and trailing slashes from the url. This is done to make sure the format is
-        // the same as GC nodes id.
-        const urlWithoutQuery = trimLeadingAndTrailingSlashes(request.url.split("?")[0]);
+        const dataStoreContext = await this.getDataStore(internalId, headerData, request);
         // Get the initial snapshot details which contain the data store package path.
         const details = await dataStoreContext.getInitialSnapshotDetails();
-        // Note that this will throw if the data store is inactive or tombstoned and throwing on incorrect usage
-        // is configured.
-        this.gcNodeUpdated(`/${urlWithoutQuery}`, "Loaded", undefined /* timestampMs */, details.pkg, request, headerData);
+        // When notifying GC of this node being loaded, we only indicate the DataStore itself, not the full subDataStore url if applicable.
+        // This is in case the url is to a route that Fluid doesn't understand or track for GC (e.g. if suited for a custom request handler)
+        this.gcNodeUpdated({
+            node: { type: "DataStore", path: `/${id}` },
+            reason: "Loaded",
+            packagePath: details.pkg,
+            request,
+            headerData,
+        });
         const dataStore = await dataStoreContext.realize();
         const subRequest = requestParser.createSubRequest(1);
         // We always expect createSubRequest to include a leading slash, but asserting here to protect against