@fluidframework/container-loader 2.0.0-dev.1.4.6.106135 → 2.0.0-dev.2.3.0.115467

package/lib/container.js

@@ -111,10 +111,10 @@ const getCodeProposal =
  * @param eventName - event name
  * @param action - functor to call and measure
  */
-async function ReportIfTooLong(logger, eventName, action) {
+export async function ReportIfTooLong(logger, eventName, action) {
     const event = PerformanceEvent.start(logger, { eventName });
     const props = await action();
-    if (event.duration > 1000) {
+    if (event.duration > 200) {
         event.end(props);
     }
 }
@@ -184,7 +184,7 @@ export class Container extends EventEmitterWithErrorHandling {
         });
         // Prefix all events in this file with container-loader
         this.mc = loggerToMonitoringContext(ChildLogger.create(this.subLogger, "Container"));
-        const summarizeProtocolTree = (_a = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree")) !== null && _a !== void 0 ? _a : this.loader.services.options.summarizeProtocolTree;
+        const summarizeProtocolTree = (_a = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2")) !== null && _a !== void 0 ? _a : this.loader.services.options.summarizeProtocolTree;
         this.options = Object.assign(Object.assign({}, this.loader.services.options), { summarizeProtocolTree });
         this._deltaManager = this.createDeltaManager();
         this._clientId = (_b = config.serializedContainerState) === null || _b === void 0 ? void 0 : _b.clientId;
@@ -196,15 +196,29 @@ export class Container extends EventEmitterWithErrorHandling {
                 }
                 this.logConnectionStateChangeTelemetry(value, oldState, reason);
                 if (this._lifecycleState === "loaded") {
-                    this.propagateConnectionState(false /* initial transition */);
+                    this.propagateConnectionState(false /* initial transition */, value === ConnectionState.Disconnected ? reason : undefined /* disconnectedReason */);
                 }
             },
             shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
             maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
             logConnectionIssue: (eventName, details) => {
+                const mode = this.connectionMode;
                 // We get here when socket does not receive any ops on "write" connection, including
                 // its own join op. Attempt recovery option.
-                this._deltaManager.logConnectionIssue(Object.assign({ eventName, duration: performance.now() - this.connectionTransitionTimes[ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
+                this._deltaManager.logConnectionIssue(Object.assign({ eventName,
+                    mode, duration: performance.now() - this.connectionTransitionTimes[ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
+                // If this is "write" connection, it took too long to receive join op. But in most cases that's due
+                // to very slow op fetches and we will eventually get there.
+                // For "read" connections, we get here due to self join signal not arriving on time. We will need to
+                // better understand when and why it may happen.
+                // For now, attempt to recover by reconnecting. In future, maybe we can query relay service for
+                // current state of audience.
+                // Other possible recovery path - move to connected state (i.e. ConnectionStateHandler.joinOpTimer
+                // to call this.applyForConnectedState("addMemberEvent") for "read" connections)
+                if (mode === "read") {
+                    this.disconnect();
+                    this.connect();
+                }
             },
         }, this.deltaManager, this._clientId);
         this.on(savedContainerEvent, () => {
@@ -924,10 +938,9 @@ export class Container extends EventEmitterWithErrorHandling {
         this.initializeProtocolState(attributes, quorumSnapshot);
     }
     initializeProtocolState(attributes, quorumSnapshot) {
-        var _a, _b;
+        var _a;
         const protocolHandlerBuilder = (_a = this.protocolHandlerBuilder) !== null && _a !== void 0 ? _a : ((...args) => new ProtocolHandler(...args, new Audience()));
-        const protocol = protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(MessageType.Propose, JSON.stringify({ key, value })), (_b = this._initialClients) !== null && _b !== void 0 ? _b : []);
-        this._initialClients = undefined;
+        const protocol = protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(MessageType.Propose, JSON.stringify({ key, value })));
         const protocolLogger = ChildLogger.create(this.subLogger, "ProtocolHandler");
         protocol.quorum.on("error", (error) => {
             protocolLogger.sendErrorEvent(error);
@@ -1026,21 +1039,8 @@ export class Container extends EventEmitterWithErrorHandling {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inboundSignal.pause();
         deltaManager.on("connect", (details, _opsBehind) => {
-            var _a;
-            if (this._protocolHandler === undefined) {
-                // Store the initial clients so that they can be submitted to the
-                // protocol handler when it is created.
-                this._initialClients = details.initialClients;
-            }
-            else {
-                // When reconnecting, the protocol handler is already created,
-                // so we can update the audience right now.
-                this._protocolHandler.audience.clear();
-                for (const priorClient of (_a = details.initialClients) !== null && _a !== void 0 ? _a : []) {
-                    this._protocolHandler.audience.addMember(priorClient.clientId, priorClient.client);
-                }
-            }
-            this.connectionStateHandler.receivedConnectEvent(this.connectionMode, details);
+            assert(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
+            this.connectionStateHandler.receivedConnectEvent(details);
         });
         deltaManager.on("disconnect", (reason) => {
             var _a;
@@ -1052,7 +1052,7 @@ export class Container extends EventEmitterWithErrorHandling {
             // Some "warning" events come from outside the container and are logged
             // elsewhere (e.g. summarizing container). We shouldn't log these here.
             if (warn.logged !== true) {
-                this.logContainerError(warn);
+                this.mc.logger.sendTelemetryEvent({ eventName: "ContainerWarning" }, warn);
             }
             this.emit("warning", warn);
         });
@@ -1111,7 +1111,7 @@ export class Container extends EventEmitterWithErrorHandling {
             this.firstConnection = false;
         }
     }
-    propagateConnectionState(initialTransition) {
+    propagateConnectionState(initialTransition, disconnectedReason) {
         var _a;
         // When container loaded, we want to propagate initial connection state.
         // After that, we communicate only transitions to Connected & Disconnected states, skipping all other states.
@@ -1131,7 +1131,7 @@ export class Container extends EventEmitterWithErrorHandling {
         // Both protocol and context should not be undefined if we got so far.
         this.setContextConnectedState(state, (_a = this._deltaManager.connectionManager.readOnlyInfo.readonly) !== null && _a !== void 0 ? _a : false);
         this.protocolHandler.setConnectionState(state, this.clientId);
-        raiseConnectedEvent(this.mc.logger, this, state, this.clientId);
+        raiseConnectedEvent(this.mc.logger, this, state, this.clientId, disconnectedReason);
         if (logOpsOnReconnect) {
             this.mc.logger.sendTelemetryEvent({ eventName: "OpsSentOnReconnect", count: this.messageCountAfterDisconnection });
         }
@@ -1153,7 +1153,7 @@ export class Container extends EventEmitterWithErrorHandling {
         let clientSequenceNumber = -1;
         for (const message of batch) {
             clientSequenceNumber = this.submitMessage(MessageType.Operation, message.contents, true, // batch
-            message.metadata);
+            message.metadata, message.compression);
         }
         this._deltaManager.flush();
         return clientSequenceNumber;
@@ -1170,7 +1170,7 @@ export class Container extends EventEmitterWithErrorHandling {
             this.options.summarizeProtocolTree === true;
         return this.submitMessage(MessageType.Summarize, JSON.stringify(summary), false /* batch */);
     }
-    submitMessage(type, contents, batch, metadata) {
+    submitMessage(type, contents, batch, metadata, compression) {
         var _a;
         if (this.connectionState !== ConnectionState.Connected) {
             this.mc.logger.sendErrorEvent({ eventName: "SubmitMessageWithNoConnection", type });
@@ -1178,14 +1178,14 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         this.messageCountAfterDisconnection += 1;
         (_a = this.collabWindowTracker) === null || _a === void 0 ? void 0 : _a.stopSequenceNumberUpdate();
-        return this._deltaManager.submit(type, contents, batch, metadata);
+        return this._deltaManager.submit(type, contents, batch, metadata, compression);
     }
     processRemoteMessage(message) {
         const local = this.clientId === message.clientId;
         // Allow the protocol handler to process the message
         const result = this.protocolHandler.processMessage(message, local);
         // Forward messages to the loaded runtime for processing
-        this.context.process(message, local, undefined);
+        this.context.process(message, local);
         // Inactive (not in quorum or not writers) clients don't take part in the minimum sequence number calculation.
         if (this.activeConnection()) {
             if (this.collabWindowTracker === undefined) {
@@ -1196,9 +1196,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 assert(this.serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
                 this.collabWindowTracker = new CollabWindowTracker((type) => {
                     assert(this.activeConnection(), 0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
-                    // back-compat: There is a bug in 1.2 runtime where clients cannot handle
-                    // ops whose contents are undefined
-                    this.submitMessage(type, null);
+                    this.submitMessage(type);
                 }, this.serviceConfiguration.noopTimeFrequency, this.serviceConfiguration.noopCountFrequency);
             }
             this.collabWindowTracker.scheduleSequenceNumberUpdate(message, result.immediateNoOp === true);
@@ -1260,9 +1258,6 @@ export class Container extends EventEmitterWithErrorHandling {
         this._dirtyContainer = dirty;
         this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
     }
-    logContainerError(warning) {
-        this.mc.logger.sendErrorEvent({ eventName: "ContainerWarning" }, warning);
-    }
     /**
      * Set the connected state of the ContainerContext
      * This controls the "connected" state of the ContainerRuntime as well