@fluidframework/container-loader 2.0.0-dev.5.2.0.169897 → 2.0.0-dev.6.4.0.191258

package/lib/deltaManager.js

@@ -2,16 +2,16 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { default as AbortController } from "abort-controller";
 import { v4 as uuid } from "uuid";
-import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
-import { normalizeError, logIfFalse, safeRaiseEvent, isFluidError, } from "@fluidframework/telemetry-utils";
-import { DriverErrorType, } from "@fluidframework/driver-definitions";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { assert } from "@fluidframework/core-utils";
+import { DataProcessingError, extractSafePropertiesFromMessage, normalizeError, logIfFalse, safeRaiseEvent, isFluidError, DataCorruptionError, UsageError, } from "@fluidframework/telemetry-utils";
+import { DriverErrorTypes, } from "@fluidframework/driver-definitions";
 import { MessageType, } from "@fluidframework/protocol-definitions";
 import { NonRetryableError, isRuntimeMessage, MessageType2 } from "@fluidframework/driver-utils";
-import { ThrottlingWarning, DataCorruptionError, extractSafePropertiesFromMessage, DataProcessingError, UsageError, } from "@fluidframework/container-utils";
 import { DeltaQueue } from "./deltaQueue";
 import { OnlyValidTermValue } from "./protocol";
+import { ThrottlingWarning } from "./error";
 /**
  * Determines if message was sent by client, not service
  */
@@ -88,7 +88,7 @@ export class DeltaManager extends TypedEventEmitter {
             signalHandler: (message) => this._inboundSignal.push(message),
             reconnectionDelayHandler: (delayMs, error) => this.emitDelayInfo(this.deltaStreamDelayId, delayMs, error),
             closeHandler: (error) => this.close(error),
-            disconnectHandler: (reason, error) => this.disconnectHandler(reason, error),
+            disconnectHandler: (reason) => this.disconnectHandler(reason),
             connectHandler: (connection) => this.connectHandler(connection),
             pongHandler: (latency) => this.emit("pong", latency),
             readonlyChangeHandler: (readonly) => safeRaiseEvent(this, this.logger, "readonly", readonly),
@@ -179,7 +179,7 @@ export class DeltaManager extends TypedEventEmitter {
     }
     submit(type, contents, batch = false, metadata, compression, referenceSequenceNumber) {
         // Back-compat ADO:3455
-        const backCompatRefSeqNum = referenceSequenceNumber !== null && referenceSequenceNumber !== void 0 ? referenceSequenceNumber : this.lastProcessedSequenceNumber;
+        const backCompatRefSeqNum = referenceSequenceNumber ?? this.lastProcessedSequenceNumber;
         const messagePartial = {
             contents,
             metadata,
@@ -212,7 +212,6 @@ export class DeltaManager extends TypedEventEmitter {
         return this.connectionManager.submitSignal(content);
     }
     flush() {
-        var _a, _b, _c;
         const batch = this.messageBuffer;
         if (batch.length === 0) {
             return;
@@ -221,17 +220,22 @@ export class DeltaManager extends TypedEventEmitter {
         // The prepareFlush event allows listeners to append metadata to the batch prior to submission.
         this.emit("prepareSend", batch);
         if (batch.length === 1) {
-            assert(((_a = batch[0].metadata) === null || _a === void 0 ? void 0 : _a.batch) === undefined, 0x3c9 /* no batch markup on single message */);
+            assert(batch[0].metadata?.batch === undefined, 0x3c9 /* no batch markup on single message */);
         }
         else {
-            assert(((_b = batch[0].metadata) === null || _b === void 0 ? void 0 : _b.batch) === true, 0x3ca /* no start batch markup */);
-            assert(((_c = batch[batch.length - 1].metadata) === null || _c === void 0 ? void 0 : _c.batch) === false, 0x3cb /* no end batch markup */);
+            assert(batch[0].metadata?.batch === true, 0x3ca /* no start batch markup */);
+            assert(batch[batch.length - 1].metadata?.batch === false, 0x3cb /* no end batch markup */);
         }
         this.connectionManager.sendMessages(batch);
         assert(this.messageBuffer.length === 0, 0x3cc /* reentrancy */);
     }
     get connectionProps() {
-        return Object.assign({ sequenceNumber: this.lastSequenceNumber, opsSize: this.opsSize > 0 ? this.opsSize : undefined }, this.connectionManager.connectionProps);
+        return {
+            sequenceNumber: this.lastSequenceNumber,
+            opsSize: this.opsSize > 0 ? this.opsSize : undefined,
+            deltaManagerState: this._disposed ? "disposed" : this._closed ? "closed" : "open",
+            ...this.connectionManager.connectionProps,
+        };
     }
     /**
      * Log error event with a bunch of internal to DeltaManager information about state of op processing
@@ -240,15 +244,25 @@ export class DeltaManager extends TypedEventEmitter {
      * @param event - Event to log.
      */
     logConnectionIssue(event) {
-        var _a;
         assert(this.connectionManager.connected, 0x238 /* "called only in connected state" */);
         const pendingSorted = this.pending.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
-        this.logger.sendErrorEvent(Object.assign(Object.assign(Object.assign(Object.assign({}, event), { 
+        this.logger.sendErrorEvent({
+            ...event,
             // This directly tells us if fetching ops is in flight, and thus likely the reason of
             // stalled op processing
-            fetchReason: this.fetchReason, 
+            fetchReason: this.fetchReason,
             // A bunch of useful sequence numbers to understand if we are holding some ops from processing
-            lastQueuedSequenceNumber: this.lastQueuedSequenceNumber, lastProcessedSequenceNumber: this.lastProcessedSequenceNumber, lastObserved: this.lastObservedSeqNumber }), this.connectionManager.connectionVerboseProps), { pendingOps: this.pending.length, pendingFirst: (_a = pendingSorted[0]) === null || _a === void 0 ? void 0 : _a.sequenceNumber, haveHandler: this.handler !== undefined, inboundLength: this.inbound.length, inboundPaused: this.inbound.paused }));
+            lastQueuedSequenceNumber: this.lastQueuedSequenceNumber,
+            lastProcessedSequenceNumber: this.lastProcessedSequenceNumber,
+            lastObserved: this.lastObservedSeqNumber,
+            // connection info
+            ...this.connectionManager.connectionVerboseProps,
+            pendingOps: this.pending.length,
+            pendingFirst: pendingSorted[0]?.sequenceNumber,
+            haveHandler: this.handler !== undefined,
+            inboundLength: this.inbound.length,
+            inboundPaused: this.inbound.paused,
+        });
     }
     cancelEstablishingConnection(reason) {
         this.emit("cancelEstablishingConnection", reason);
@@ -333,8 +347,7 @@ export class DeltaManager extends TypedEventEmitter {
         assert(this.fetchReason !== undefined || this.pending.length === 0, 0x269 /* "pending ops are not dropped" */);
     }
     connect(args) {
-        var _a;
-        const fetchOpsFromStorage = (_a = args.fetchOpsFromStorage) !== null && _a !== void 0 ? _a : true;
+        const fetchOpsFromStorage = args.fetchOpsFromStorage ?? true;
         logIfFalse(this.handler !== undefined || !fetchOpsFromStorage, this.logger, "CantFetchWithoutBaseline"); // can't fetch if no baseline
         // Note: There is race condition here.
         // We want to issue request to storage as soon as possible, to
@@ -347,7 +360,7 @@ export class DeltaManager extends TypedEventEmitter {
         // on the wire, we might be always behind.
         // See comment at the end of "connect" handler
         if (fetchOpsFromStorage) {
-            this.fetchMissingDeltas(args.reason);
+            this.fetchMissingDeltas(args.reason.text);
         }
         this.connectionManager.connect(args.reason, args.mode);
     }
@@ -367,8 +380,14 @@ export class DeltaManager extends TypedEventEmitter {
             // It is possible that due to asynchrony (including await above), required ops were already
             // received through delta stream. Validate that before moving forward.
             if (this.lastQueuedSequenceNumber >= lastExpectedOp) {
-                this.logger.sendPerformanceEvent(Object.assign({ reason: fetchReason, eventName: "ExtraStorageCall", early: true, from,
-                    to }, this.connectionManager.connectionVerboseProps));
+                this.logger.sendPerformanceEvent({
+                    reason: fetchReason,
+                    eventName: "ExtraStorageCall",
+                    early: true,
+                    from,
+                    to,
+                    ...this.connectionManager.connectionVerboseProps,
+                });
                 return;
             }
             // Be prepared for the case where webSocket would receive the ops that we are trying to fill through
@@ -393,14 +412,17 @@ export class DeltaManager extends TypedEventEmitter {
             // This is useless for known ranges (to is defined) as it means request is over either way.
             // And it will cancel unbound request too early, not allowing us to learn where the end of the file is.
             if (!opsFromFetch && cancelFetch(op)) {
-                controller.abort();
+                // TODO: Remove when typescript version of the repo contains the AbortSignal.reason property (AB#5045)
+                controller.abort("DeltaManager getDeltas fetch cancelled");
                 this._inbound.off("push", opListener);
             }
         };
         try {
             this._inbound.on("push", opListener);
             assert(this.closeAbortController.signal.onabort === null, 0x1e8 /* "reentrancy" */);
-            this.closeAbortController.signal.onabort = () => controller.abort();
+            this.closeAbortController.signal.onabort = () => 
+            // TODO: Remove when typescript version of the repo contains the AbortSignal.reason property (AB#5045)
+            controller.abort(this.closeAbortController.signal.reason);
             const stream = this.deltaStorage.fetchMessages(from, // inclusive
             to, // exclusive
             controller.signal, cacheOnly, fetchReason);
@@ -420,6 +442,14 @@ export class DeltaManager extends TypedEventEmitter {
             }
         }
         finally {
+            if (controller.signal.aborted) {
+                this.logger.sendTelemetryEvent({
+                    eventName: "DeltaManager_GetDeltasAborted",
+                    fetchReason,
+                    // TODO: Remove when typescript version of the repo contains the AbortSignal.reason property (AB#5045)
+                    reason: controller.signal.reason,
+                });
+            }
             this.closeAbortController.signal.onabort = null;
             this._inbound.off("push", opListener);
             assert(!opsFromFetch, 0x289 /* "logic error" */);
@@ -467,7 +497,8 @@ export class DeltaManager extends TypedEventEmitter {
         this.removeAllListeners();
     }
     clearQueues() {
-        this.closeAbortController.abort();
+        // TODO: Remove when typescript version of the repo contains the AbortSignal.reason property (AB#5045)
+        this.closeAbortController.abort("DeltaManager is closed");
         this._inbound.clear();
         this._inboundSignal.clear();
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
@@ -483,9 +514,9 @@ export class DeltaManager extends TypedEventEmitter {
             this.timeTillThrottling = 0;
         }
     }
-    disconnectHandler(reason, error) {
+    disconnectHandler(reason) {
         this.messageBuffer.length = 0;
-        this.emit("disconnect", reason, error);
+        this.emit("disconnect", reason);
     }
     /**
      * Emit info about a delay in service communication on account of throttling.
@@ -513,7 +544,6 @@ export class DeltaManager extends TypedEventEmitter {
         return `${m.clientId}-${m.type}-${m.minimumSequenceNumber}-${m.referenceSequenceNumber}-${m.timestamp}`;
     }
     enqueueMessages(messages, reason, allowGaps = false) {
-        var _a, _b;
         if (this.handler === undefined) {
             // We did not setup handler yet.
             // This happens when we connect to web socket faster than we get attributes for container
@@ -576,19 +606,32 @@ export class DeltaManager extends TypedEventEmitter {
             // Do not report when pending fetch is in progress, as such reporting will not
             // correctly take into account pending ops.
             if (eventName !== undefined) {
-                this.logger.sendPerformanceEvent(Object.assign({ eventName,
-                    reason, previousReason: this.prevEnqueueMessagesReason, from, to: last + 1, length: messages.length, fetchReason: this.fetchReason, duplicate: duplicate > 0 ? duplicate : undefined, initialGap: initialGap !== 0 ? initialGap : undefined, gap: gap > 0 ? gap : undefined, firstMissing, dmInitialSeqNumber: this.initialSequenceNumber }, this.connectionManager.connectionVerboseProps));
+                this.logger.sendPerformanceEvent({
+                    eventName,
+                    reason,
+                    previousReason: this.prevEnqueueMessagesReason,
+                    from,
+                    to: last + 1,
+                    length: messages.length,
+                    fetchReason: this.fetchReason,
+                    duplicate: duplicate > 0 ? duplicate : undefined,
+                    initialGap: initialGap !== 0 ? initialGap : undefined,
+                    gap: gap > 0 ? gap : undefined,
+                    firstMissing,
+                    dmInitialSeqNumber: this.initialSequenceNumber,
+                    ...this.connectionManager.connectionVerboseProps,
+                });
             }
         }
         this.updateLatestKnownOpSeqNumber(messages[messages.length - 1].sequenceNumber);
-        const n = (_a = this.previouslyProcessedMessage) === null || _a === void 0 ? void 0 : _a.sequenceNumber;
+        const n = this.previouslyProcessedMessage?.sequenceNumber;
         assert(n === undefined || n === this.lastQueuedSequenceNumber, 0x0ec /* "Unexpected value for previously processed message's sequence number" */);
         for (const message of messages) {
             // Check that the messages are arriving in the expected order
             if (message.sequenceNumber <= this.lastQueuedSequenceNumber) {
                 // Validate that we do not have data loss, i.e. sequencing is reset and started again
                 // with numbers that this client already observed before.
-                if (((_b = this.previouslyProcessedMessage) === null || _b === void 0 ? void 0 : _b.sequenceNumber) === message.sequenceNumber) {
+                if (this.previouslyProcessedMessage?.sequenceNumber === message.sequenceNumber) {
                     const message1 = this.comparableMessagePayload(this.previouslyProcessedMessage);
                     const message2 = this.comparableMessagePayload(message);
                     if (message1 !== message2) {
@@ -601,7 +644,7 @@ export class DeltaManager extends TypedEventEmitter {
                         // instances such that the same sequence number is reused for two different ops.
                         // pre-0.58 error message: twoMessagesWithSameSeqNumAndDifferentPayload
                         "Found two messages with the same sequenceNumber but different payloads. Likely to be a " +
-                            "service issue", DriverErrorType.fileOverwrittenInStorage, {
+                            "service issue", DriverErrorTypes.fileOverwrittenInStorage, {
                             clientId: this.connectionManager.clientId,
                             sequenceNumber: message.sequenceNumber,
                             message1,
@@ -639,7 +682,10 @@ export class DeltaManager extends TypedEventEmitter {
         // 1. (Legacy) We can see message.type === "attach" or "chunkedOp" for legacy files before RTM
         // 2. Non-immediate noops (contents: null) can be sent by service without clientId
         if (!isString && isClientMessage(message) && message.type !== MessageType.NoOp) {
-            throw new DataCorruptionError("Mismatch in clientId", Object.assign(Object.assign({}, extractSafePropertiesFromMessage(message)), { messageType: message.type }));
+            throw new DataCorruptionError("Mismatch in clientId", {
+                ...extractSafePropertiesFromMessage(message),
+                messageType: message.type,
+            });
         }
         // TODO Remove after SPO picks up the latest build.
         if (typeof message.contents === "string" &&
@@ -665,7 +711,10 @@ export class DeltaManager extends TypedEventEmitter {
         // Watch the minimum sequence number and be ready to update as needed
         if (this.minSequenceNumber > message.minimumSequenceNumber) {
             // pre-0.58 error message: msnMovesBackwards
-            throw new DataCorruptionError("Found a lower minimumSequenceNumber (msn) than previously recorded", Object.assign(Object.assign({}, extractSafePropertiesFromMessage(message)), { clientId: this.connectionManager.clientId }));
+            throw new DataCorruptionError("Found a lower minimumSequenceNumber (msn) than previously recorded", {
+                ...extractSafePropertiesFromMessage(message),
+                clientId: this.connectionManager.clientId,
+            });
         }
         // Client ops: MSN has to be lower than sequence #, as client can continue to send ops with same
         // reference sequence number as this op.
@@ -677,7 +726,10 @@ export class DeltaManager extends TypedEventEmitter {
         this.minSequenceNumber = message.minimumSequenceNumber;
         if (message.sequenceNumber !== this.lastProcessedSequenceNumber + 1) {
             // pre-0.58 error message: nonSequentialSequenceNumber
-            throw new DataCorruptionError("Found a non-Sequential sequenceNumber", Object.assign(Object.assign({}, extractSafePropertiesFromMessage(message)), { clientId: this.connectionManager.clientId }));
+            throw new DataCorruptionError("Found a non-Sequential sequenceNumber", {
+                ...extractSafePropertiesFromMessage(message),
+                clientId: this.connectionManager.clientId,
+            });
         }
         this.lastProcessedSequenceNumber = message.sequenceNumber;
         // a bunch of code assumes that this is true
@@ -708,7 +760,6 @@ export class DeltaManager extends TypedEventEmitter {
      * Retrieves the missing deltas between the given sequence numbers
      */
     async fetchMissingDeltasCore(reason, cacheOnly, to) {
-        var _a;
         // Exit out early if we're already fetching deltas
         if (this.fetchReason !== undefined) {
             return;
@@ -727,7 +778,7 @@ export class DeltaManager extends TypedEventEmitter {
         }
         try {
             let from = this.lastQueuedSequenceNumber + 1;
-            const n = (_a = this.previouslyProcessedMessage) === null || _a === void 0 ? void 0 : _a.sequenceNumber;
+            const n = this.previouslyProcessedMessage?.sequenceNumber;
             if (n !== undefined) {
                 // If we already processed at least one op, then we have this.previouslyProcessedMessage populated
                 // and can use it to validate that we are operating on same file, i.e. it was not overwritten.