@fluidframework/container-runtime 2.4.0-297385 → 2.4.0-299707

package/lib/containerRuntime.js

@@ -32,16 +32,23 @@ import { ScheduleManager } from "./scheduleManager.js";
 import { DocumentsSchemaController, OrderedClientCollection, OrderedClientElection, RetriableSummaryError, RunWhileConnectedCoordinator, Summarizer, SummarizerClientElection, SummaryCollection, SummaryManager, aliasBlobName, chunksBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, idCompressorBlobName, metadataBlobName, rootHasIsolatedChannels, summarizerClientType, wrapSummaryInChannelsTree, } from "./summary/index.js";
 import { Throttler, formExponentialFn } from "./throttler.js";
 /**
- * Utility to implement compat behaviors given an unknown message type
+ * Creates an error object to be thrown / passed to Container's close fn in case of an unknown message type.
  * The parameters are typed to support compile-time enforcement of handling all known types/behaviors
  *
- * @param _unknownContainerRuntimeMessageType - Typed as something unexpected, to ensure all known types have been
+ * @param unknownContainerRuntimeMessageType - Typed as something unexpected, to ensure all known types have been
  * handled before calling this function (e.g. in a switch statement).
- * @param compatBehavior - Typed redundantly with CompatModeBehavior to ensure handling is added when updating that type
+ *
+ * @param codePath - The code path where the unexpected message type was encountered.
+ *
+ * @param sequencedMessage - The sequenced message that contained the unexpected message type.
+ *
  */
-function compatBehaviorAllowsMessageType(_unknownContainerRuntimeMessageType, compatBehavior) {
-    // undefined defaults to same behavior as "FailToProcess"
-    return compatBehavior === "Ignore";
+function getUnknownMessageTypeError(unknownContainerRuntimeMessageType, codePath, sequencedMessage) {
+    return DataProcessingError.create("Runtime message of unknown type", codePath, sequencedMessage, {
+        messageDetails: {
+            type: unknownContainerRuntimeMessageType,
+        },
+    });
 }
 /**
  * @legacy
@@ -814,7 +821,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         parentContext.submitSignal = (type, content, targetClientId) => {
             const envelope1 = content;
             const envelope2 = this.createNewSignalEnvelope(envelope1.address, type, envelope1.contents);
-            return this.submitSignalFn(envelope2, targetClientId);
+            return this.submitEnvelopedSignal(envelope2, targetClientId);
         };
         let snapshot = getSummaryForDatastores(baseSnapshot, metadata);
         if (snapshot !== undefined && snapshotWithContents !== undefined) {
@@ -1389,22 +1396,9 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // GC op is only sent in summarizer which should never have stashed ops.
                 throw new LoggingError("GC op not expected to be stashed in summarizer");
             default: {
-                // This should be extremely rare for stashed ops.
-                // It would require a newer runtime stashing ops and then an older one applying them,
-                // e.g. if an app rolled back its container version
-                const compatBehavior = opContents.compatDetails?.behavior;
-                if (!compatBehaviorAllowsMessageType(opContents.type, compatBehavior)) {
-                    const error = DataProcessingError.create("Stashed runtime message of unexpected type", "applyStashedOp", undefined /* sequencedMessage */, {
-                        messageDetails: JSON.stringify({
-                            type: opContents.type,
-                            compatBehavior,
-                        }),
-                    });
-                    this.closeFn(error);
-                    throw error;
-                }
-                // Note: Even if its compat behavior allows it, we don't know how to apply this stashed op.
-                // All we can do is ignore it (similar to on process).
+                const error = getUnknownMessageTypeError(opContents.type, "applyStashedOp" /* codePath */);
+                this.closeFn(error);
+                throw error;
             }
         }
     }
@@ -1724,23 +1718,9 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.documentsSchemaController.processDocumentSchemaOp(message.contents, local, message.sequenceNumber);
                 break;
             default: {
-                const compatBehavior = message.compatDetails?.behavior;
-                if (!compatBehaviorAllowsMessageType(message.type, compatBehavior)) {
-                    const error = DataProcessingError.create(
-                    // Former assert 0x3ce
-                    "Runtime message of unknown type", "OpProcessing", message, {
-                        local,
-                        messageDetails: JSON.stringify({
-                            type: message.type,
-                            contentType: typeof message.contents,
-                            compatBehavior,
-                            batch: message.metadata?.batch,
-                            compression: message.compression,
-                        }),
-                    });
-                    this.closeFn(error);
-                    throw error;
-                }
+                const error = getUnknownMessageTypeError(message.type, "validateAndProcessRuntimeMessage" /* codePath */, message);
+                this.closeFn(error);
+                throw error;
             }
         }
         this.emit("op", message, true /* runtimeMessage */);
@@ -1763,6 +1743,60 @@ export class ContainerRuntime extends TypedEventEmitter {
         this._signalTracking.signalTimestamp = 0;
         this._signalTracking.totalSignalsSentInLatencyWindow = 0;
     }
+    /**
+     * Updates signal telemetry including emitting telemetry events.
+     */
+    processSignalForTelemetry(envelope) {
+        const { clientBroadcastSignalSequenceNumber } = envelope;
+        if (clientBroadcastSignalSequenceNumber === undefined) {
+            return;
+        }
+        if (this._signalTracking.trackingSignalSequenceNumber === undefined ||
+            this._signalTracking.minimumTrackingSignalSequenceNumber === undefined) {
+            return;
+        }
+        if (clientBroadcastSignalSequenceNumber >= this._signalTracking.trackingSignalSequenceNumber) {
+            // Calculate the number of signals lost and log the event.
+            const signalsLost = clientBroadcastSignalSequenceNumber -
+                this._signalTracking.trackingSignalSequenceNumber;
+            if (signalsLost > 0) {
+                this._signalTracking.signalsLost += signalsLost;
+                this.mc.logger.sendErrorEvent({
+                    eventName: "SignalLost",
+                    signalsLost, // Number of lost signals detected.
+                    trackingSequenceNumber: this._signalTracking.trackingSignalSequenceNumber, // The next expected signal sequence number.
+                    clientBroadcastSignalSequenceNumber, // Actual signal sequence number received.
+                });
+            }
+            // Update the tracking signal sequence number to the next expected signal in the sequence.
+            this._signalTracking.trackingSignalSequenceNumber =
+                clientBroadcastSignalSequenceNumber + 1;
+        }
+        else if (
+        // Check if this is a signal in range of interest.
+        clientBroadcastSignalSequenceNumber >=
+            this._signalTracking.minimumTrackingSignalSequenceNumber) {
+            this._signalTracking.signalsOutOfOrder++;
+            this.mc.logger.sendTelemetryEvent({
+                eventName: "SignalOutOfOrder",
+                type: envelope.contents.type, // Type of signal that was received out of order.
+                trackingSequenceNumber: this._signalTracking.trackingSignalSequenceNumber, // The next expected signal sequence number.
+                clientBroadcastSignalSequenceNumber, // Sequence number of the out of order signal.
+            });
+        }
+        if (this._signalTracking.roundTripSignalSequenceNumber !== undefined &&
+            clientBroadcastSignalSequenceNumber >= this._signalTracking.roundTripSignalSequenceNumber) {
+            if (clientBroadcastSignalSequenceNumber ===
+                this._signalTracking.roundTripSignalSequenceNumber) {
+                // Latency tracked signal has been received.
+                // We now log the roundtrip duration of the tracked signal.
+                // This telemetry event also logs metrics for signals sent, signals lost, and out of order signals received.
+                // These metrics are reset after logging the telemetry event.
+                this.sendSignalTelemetryEvent();
+            }
+            this._signalTracking.roundTripSignalSequenceNumber = undefined;
+        }
+    }
     processSignal(message, local) {
         const envelope = message.content;
         const transformed = {
@@ -1773,52 +1807,14 @@ export class ContainerRuntime extends TypedEventEmitter {
         };
         // Only collect signal telemetry for broadcast messages sent by the current client.
         if (message.clientId === this.clientId &&
-            this.connected &&
-            envelope.clientBroadcastSignalSequenceNumber !== undefined) {
-            if (this._signalTracking.trackingSignalSequenceNumber !== undefined &&
-                this._signalTracking.minimumTrackingSignalSequenceNumber !== undefined) {
-                if (envelope.clientBroadcastSignalSequenceNumber >=
-                    this._signalTracking.trackingSignalSequenceNumber) {
-                    // Calculate the number of signals lost and log the event.
-                    const signalsLost = envelope.clientBroadcastSignalSequenceNumber -
-                        this._signalTracking.trackingSignalSequenceNumber;
-                    if (signalsLost > 0) {
-                        this._signalTracking.signalsLost += signalsLost;
-                        this.mc.logger.sendErrorEvent({
-                            eventName: "SignalLost",
-                            signalsLost, // Number of lost signals detected.
-                            trackingSequenceNumber: this._signalTracking.trackingSignalSequenceNumber, // The next expected signal sequence number.
-                            clientBroadcastSignalSequenceNumber: envelope.clientBroadcastSignalSequenceNumber, // Actual signal sequence number received.
-                        });
-                    }
-                    // Update the tracking signal sequence number to the next expected signal in the sequence.
-                    this._signalTracking.trackingSignalSequenceNumber =
-                        envelope.clientBroadcastSignalSequenceNumber + 1;
-                }
-                else if (envelope.clientBroadcastSignalSequenceNumber >=
-                    this._signalTracking.minimumTrackingSignalSequenceNumber) {
-                    this._signalTracking.signalsOutOfOrder++;
-                    this.mc.logger.sendTelemetryEvent({
-                        eventName: "SignalOutOfOrder",
-                        type: envelope.contents.type, // Type of signal that was received out of order.
-                        trackingSequenceNumber: this._signalTracking.trackingSignalSequenceNumber, // The next expected signal sequence number.
-                        clientBroadcastSignalSequenceNumber: envelope.clientBroadcastSignalSequenceNumber, // Sequence number of the out of order signal.
-                    });
-                }
-                if (this._signalTracking.roundTripSignalSequenceNumber !== undefined &&
-                    envelope.clientBroadcastSignalSequenceNumber >=
-                        this._signalTracking.roundTripSignalSequenceNumber) {
-                    if (envelope.clientBroadcastSignalSequenceNumber ===
-                        this._signalTracking.roundTripSignalSequenceNumber) {
-                        // Latency tracked signal has been received.
-                        // We now log the roundtrip duration of the tracked signal.
-                        // This telemetry event also logs metrics for signals sent, signals lost, and out of order signals received.
-                        // These metrics are reset after logging the telemetry event.
-                        this.sendSignalTelemetryEvent();
-                    }
-                    this._signalTracking.roundTripSignalSequenceNumber = undefined;
-                }
-            }
+            // jason-ha: This `connected` check seems incorrect. Signals that come through
+            // here must have been received while connected to service and there is no need
+            // to avoid processing when connection has dropped. Because container runtime's
+            // `connected` (and `_connected`) state also reflects some ops state, it may
+            //  easily be false when newly connected and signal tracking may very well
+            // complain lost signals (that were simply skipped per this check).
+            this.connected) {
+            this.processSignalForTelemetry(envelope);
         }
         if (envelope.address === undefined) {
             // No address indicates a container signal message.
@@ -1993,16 +1989,20 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         return true;
     }
-    createNewSignalEnvelope(address, type, content, targetClientId) {
+    createNewSignalEnvelope(address, type, content) {
         const newEnvelope = {
             address,
             contents: { type, content },
         };
+        return newEnvelope;
+    }
+    submitEnvelopedSignal(envelope, targetClientId) {
         const isBroadcastSignal = targetClientId === undefined;
         if (isBroadcastSignal) {
             const clientBroadcastSignalSequenceNumber = ++this._signalTracking
                 .broadcastSignalSequenceNumber;
-            newEnvelope.clientBroadcastSignalSequenceNumber = clientBroadcastSignalSequenceNumber;
+            // Stamp with the broadcast signal sequence number.
+            envelope.clientBroadcastSignalSequenceNumber = clientBroadcastSignalSequenceNumber;
             this._signalTracking.signalsSentSinceLastLatencyMeasurement++;
             if (this._signalTracking.minimumTrackingSignalSequenceNumber === undefined ||
                 this._signalTracking.trackingSignalSequenceNumber === undefined) {
@@ -2024,7 +2024,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this._signalTracking.signalsSentSinceLastLatencyMeasurement = 0;
             }
         }
-        return newEnvelope;
+        this.submitSignalFn(envelope, targetClientId);
     }
     /**
      * Submits the signal to be sent to other clients.
@@ -2040,8 +2040,8 @@ export class ContainerRuntime extends TypedEventEmitter {
      */
     submitSignal(type, content, targetClientId) {
         this.verifyNotClosed();
-        const envelope = this.createNewSignalEnvelope(undefined /* address */, type, content, targetClientId);
-        return this.submitSignalFn(envelope, targetClientId);
+        const envelope = this.createNewSignalEnvelope(undefined /* address */, type, content);
+        return this.submitEnvelopedSignal(envelope, targetClientId);
     }
     setAttachState(attachState) {
         if (attachState === AttachState.Attaching) {
@@ -2828,26 +2828,9 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // send any ops, as some other client already changed schema.
                 break;
             default: {
-                // This case should be very rare - it would imply an op was stashed from a
-                // future version of runtime code and now is being applied on an older version.
-                const compatBehavior = message.compatDetails?.behavior;
-                if (compatBehaviorAllowsMessageType(message.type, compatBehavior)) {
-                    // We do not ultimately resubmit it, to be consistent with this version of the code.
-                    this.logger.sendTelemetryEvent({
-                        eventName: "resubmitUnrecognizedMessageTypeAllowed",
-                        messageDetails: { type: message.type, compatBehavior },
-                    });
-                }
-                else {
-                    const error = DataProcessingError.create("Resubmitting runtime message of unexpected type", "reSubmitCore", undefined /* sequencedMessage */, {
-                        messageDetails: JSON.stringify({
-                            type: message.type,
-                            compatBehavior,
-                        }),
-                    });
-                    this.closeFn(error);
-                    throw error;
-                }
+                const error = getUnknownMessageTypeError(message.type, "reSubmitCore" /* codePath */);
+                this.closeFn(error);
+                throw error;
             }
         }
     }