@fluidframework/container-loader 2.0.0-internal.6.1.1 → 2.0.0-internal.6.2.0

package/dist/container.js

@@ -13,7 +13,6 @@ const merge_1 = __importDefault(require("lodash/merge"));
 const uuid_1 = require("uuid");
 const common_utils_1 = require("@fluidframework/common-utils");
 const container_definitions_1 = require("@fluidframework/container-definitions");
-const container_utils_1 = require("@fluidframework/container-utils");
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
@@ -54,7 +53,7 @@ const packageNotFactoryError = "Code package does not implement IRuntimeFactory"
 async function waitContainerToCatchUp(container) {
     // Make sure we stop waiting if container is closed.
     if (container.closed) {
-        throw new container_utils_1.UsageError("waitContainerToCatchUp: Container closed");
+        throw new telemetry_utils_1.UsageError("waitContainerToCatchUp: Container closed");
     }
     return new Promise((resolve, reject) => {
         const deltaManager = container.deltaManager;
@@ -62,8 +61,8 @@ async function waitContainerToCatchUp(container) {
             container.off("closed", closedCallback);
             const baseMessage = "Container closed while waiting to catch up";
             reject(err !== undefined
-                ? (0, telemetry_utils_1.wrapError)(err, (innerMessage) => new container_utils_1.GenericError(`${baseMessage}: ${innerMessage}`))
-                : new container_utils_1.GenericError(baseMessage));
+                ? (0, telemetry_utils_1.wrapError)(err, (innerMessage) => new telemetry_utils_1.GenericError(`${baseMessage}: ${innerMessage}`))
+                : new telemetry_utils_1.GenericError(baseMessage));
         };
         container.on("closed", closedCallback);
         // Depending on config, transition to "connected" state may include the guarantee
@@ -182,6 +181,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, detachedBlobStorage, protocolHandlerBuilder, } = createProps;
         this.connectionTransitionTimes[connectionState_1.ConnectionState.Disconnected] = common_utils_1.performance.now();
         const pendingLocalState = loadProps?.pendingLocalState;
+        this._clientId = pendingLocalState?.clientId;
         this._canReconnect = canReconnect ?? true;
         this.clientDetailsOverride = clientDetailsOverride;
         this.urlResolver = urlResolver;
@@ -346,7 +346,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 : loadMode ?? defaultMode;
             const onClosed = (err) => {
                 // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
-                reject(err ?? new container_utils_1.GenericError("Container closed without error during load"));
+                reject(err ?? new telemetry_utils_1.GenericError("Container closed without error during load"));
             };
             container.on("closed", onClosed);
             container
@@ -362,7 +362,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // Depending where error happens, we can be attempting to connect to web socket
                 // and continuously retrying (consider offline mode)
                 // Host has no container to close, so it's prudent to do it here
+                // Note: We could only dispose the container instead of just close but that would
+                // the telemetry where users sometimes search for ContainerClose event to look
+                // for load failures. So not removing this at this time.
                 container.close(err);
+                container.dispose(err);
                 onClosed(err);
             });
         }), { start: true, end: true, cancel: "generic" }, disableRecordHeapSize !== true /* recordHeapSize */);
@@ -501,7 +505,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      */
     async getEntryPoint() {
         if (this._disposed) {
-            throw new container_utils_1.UsageError("The context is already disposed");
+            throw new telemetry_utils_1.UsageError("The context is already disposed");
         }
         if (this._runtime !== undefined) {
             return this._runtime.getEntryPoint?.();
@@ -632,10 +636,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     async getPendingLocalStateCore(props) {
         if (!this.offlineLoadEnabled) {
-            throw new container_utils_1.UsageError("Can't get pending local state unless offline load is enabled");
+            throw new telemetry_utils_1.UsageError("Can't get pending local state unless offline load is enabled");
         }
         if (this.closed || this._disposed) {
-            throw new container_utils_1.UsageError("Pending state cannot be retried if the container is closed or disposed");
+            throw new telemetry_utils_1.UsageError("Pending state cannot be retried if the container is closed or disposed");
         }
         (0, common_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
         (0, common_utils_1.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
@@ -649,7 +653,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             savedOps: this.savedOps,
             url: this.resolvedUrl.url,
             term: protocol_1.OnlyValidTermValue,
-            clientId: this.clientId,
+            // no need to save this if there is no pending runtime state
+            clientId: pendingRuntimeState !== undefined ? this.clientId : undefined,
         };
         this.mc.logger.sendTelemetryEvent({ eventName: "GetPendingLocalState" });
         return JSON.stringify(pendingState);
@@ -670,11 +675,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         return JSON.stringify(combinedSummary);
     }
-    async attach(request) {
+    async attach(request, attachProps) {
         await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
             if (this._lifecycleState !== "loaded") {
                 // pre-0.58 error message: containerNotValidForAttach
-                throw new container_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}]`);
+                throw new telemetry_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}]`);
             }
             // If container is already attached or attach is in progress, throw an error.
             (0, common_utils_1.assert)(this._attachState === container_definitions_1.AttachState.Detached && !this.attachStarted, 0x205 /* "attach() called more than once" */);
@@ -754,10 +759,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 this.runtime.setAttachState(container_definitions_1.AttachState.Attached);
                 this.emit("attached");
                 if (!this.closed) {
-                    this.resumeInternal({
+                    this.handleDeltaConnectionArg({
                         fetchOpsFromStorage: false,
                         reason: { text: "createDetached" },
-                    });
+                    }, attachProps?.deltaConnection);
                 }
             }
             catch (error) {
@@ -790,10 +795,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     connect() {
         if (this.closed) {
-            throw new container_utils_1.UsageError(`The Container is closed and cannot be connected`);
+            throw new telemetry_utils_1.UsageError(`The Container is closed and cannot be connected`);
         }
         else if (this._attachState !== container_definitions_1.AttachState.Attached) {
-            throw new container_utils_1.UsageError(`The Container is not attached and cannot be connected`);
+            throw new telemetry_utils_1.UsageError(`The Container is not attached and cannot be connected`);
         }
         else if (!this.connected) {
             // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
@@ -816,7 +821,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     disconnect() {
         if (this.closed) {
-            throw new container_utils_1.UsageError(`The Container is closed and cannot be disconnected`);
+            throw new telemetry_utils_1.UsageError(`The Container is closed and cannot be disconnected`);
         }
         else {
             this.disconnectInternal({ text: "DocumentDisconnect" });
@@ -866,7 +871,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             return;
         }
         // pre-0.58 error message: existingContextDoesNotSatisfyIncomingProposal
-        const error = new container_utils_1.GenericError("Existing context does not satisfy incoming proposal");
+        const error = new telemetry_utils_1.GenericError("Existing context does not satisfy incoming proposal");
         this.close(error);
     }
     /**
@@ -917,6 +922,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * @param specifiedVersion - Version SHA to load snapshot. If not specified, will fetch the latest snapshot.
      */
     async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState, loadToSequenceNumber) {
+        const timings = { phase1: common_utils_1.performance.now() };
         this.service = await this.serviceFactory.createDocumentService(resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType);
         // Ideally we always connect as "read" by default.
         // Currently that works with SPO & r11s, because we get "write" connection when connecting to non-existing file.
@@ -947,6 +953,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             });
         }
         this._attachState = container_definitions_1.AttachState.Attached;
+        timings.phase2 = common_utils_1.performance.now();
         // Fetch specified snapshot.
         const { snapshot, versionId } = pendingLocalState === undefined
             ? await this.fetchSnapshotTree(specifiedVersion)
@@ -1019,13 +1026,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 this.attachDeltaManagerOpHandler(dmAttributes, loadMode.deltaConnection !== "none" ? "all" : "none");
                 break;
             case "sequenceNumber":
-                opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, "sequenceNumber");
-                break;
             case "cached":
-                opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, "cached");
-                break;
             case "all":
-                opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, "all");
+                opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, loadMode.opsBeforeReturn);
                 break;
             default:
                 (0, common_utils_1.unreachableCase)(loadMode.opsBeforeReturn);
@@ -1033,8 +1036,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // ...load in the existing quorum
         // Initialize the protocol handler
         await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, snapshot);
+        timings.phase3 = common_utils_1.performance.now();
         const codeDetails = this.getCodeDetailsFromQuorum();
-        await this.instantiateRuntime(codeDetails, snapshot, pendingLocalState?.pendingRuntimeState);
+        await this.instantiateRuntime(codeDetails, snapshot, 
+        // give runtime a dummy value so it knows we're loading from a stash blob
+        pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined);
         // replay saved ops
         if (pendingLocalState) {
             for (const message of pendingLocalState.savedOps) {
@@ -1043,9 +1049,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 await this.runtime.notifyOpReplay?.(message);
             }
             pendingLocalState.savedOps = [];
-            // now set clientId to stashed clientId so live ops are correctly processed as local
-            (0, common_utils_1.assert)(this.clientId === undefined, 0x5d6 /* Unexpected clientId when setting stashed clientId */);
-            this._clientId = pendingLocalState?.clientId;
         }
         // We might have hit some failure that did not manifest itself in exception in this flow,
         // do not start op processing in such case - static version of Container.load() will handle it correctly.
@@ -1057,24 +1060,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this._deltaManager.inbound.pause();
             }
-            switch (loadMode.deltaConnection) {
-                case undefined:
-                    if (pendingLocalState) {
-                        // connect to delta stream now since we did not before
-                        this.connectToDeltaStream(connectionArgs);
-                    }
-                // intentional fallthrough
-                case "delayed":
-                    (0, common_utils_1.assert)(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
-                    this.inboundQueuePausedFromInit = false;
-                    this._deltaManager.inbound.resume();
-                    this._deltaManager.inboundSignal.resume();
-                    break;
-                case "none":
-                    break;
-                default:
-                    (0, common_utils_1.unreachableCase)(loadMode.deltaConnection);
-            }
+            this.handleDeltaConnectionArg(connectionArgs, loadMode.deltaConnection, pendingLocalState !== undefined);
         }
         // If we have not yet reached `loadToSequenceNumber`, we will wait for ops to arrive until we reach it
         if (loadToSequenceNumber !== undefined &&
@@ -1099,6 +1085,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         // Internal context is fully loaded at this point
         this.setLoaded();
+        timings.end = common_utils_1.performance.now();
+        this.subLogger.sendTelemetryEvent({
+            eventName: "LoadStagesTimings",
+            details: JSON.stringify(timings),
+        }, undefined, 0 /* verbose */);
         return {
             sequenceNumber: attributes.sequenceNumber,
             version: versionId,
@@ -1402,7 +1393,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             case protocol_definitions_1.MessageType.Summarize:
                 return this.submitSummaryMessage(contents);
             default: {
-                const newError = new container_utils_1.GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type });
+                const newError = new telemetry_utils_1.GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type });
                 this.close(newError);
                 return -1;
             }
@@ -1551,6 +1542,26 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.runtime.setConnectionState(state && !readonly, this.clientId);
         }
     }
+    handleDeltaConnectionArg(connectionArgs, deltaConnectionArg, canConnect = true) {
+        switch (deltaConnectionArg) {
+            case undefined:
+                if (canConnect) {
+                    // connect to delta stream now since we did not before
+                    this.connectToDeltaStream(connectionArgs);
+                }
+            // intentional fallthrough
+            case "delayed":
+                (0, common_utils_1.assert)(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
+                this.inboundQueuePausedFromInit = false;
+                this._deltaManager.inbound.resume();
+                this._deltaManager.inboundSignal.resume();
+                break;
+            case "none":
+                break;
+            default:
+                (0, common_utils_1.unreachableCase)(deltaConnectionArg);
+        }
+    }
 }
 exports.Container = Container;
 //# sourceMappingURL=container.js.map