@fluidframework/container-loader 0.54.0-47413 → 0.55.0-48551

package/lib/container.js

@@ -12,7 +12,7 @@ import { DataCorruptionError, extractSafePropertiesFromMessage, GenericError, Us
 import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, } from "@fluidframework/driver-utils";
 import { isSystemMessage, ProtocolOpHandler, } from "@fluidframework/protocol-base";
 import { FileMode, MessageType, TreeEntry, SummaryType, } from "@fluidframework/protocol-definitions";
-import { ChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, TelemetryLogger, connectedEventName, disconnectedEventName, normalizeError, } from "@fluidframework/telemetry-utils";
+import { ChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, TelemetryLogger, connectedEventName, disconnectedEventName, normalizeError, loggerToMonitoringContext, } from "@fluidframework/telemetry-utils";
 import { Audience } from "./audience";
 import { ContainerContext } from "./containerContext";
 import { ReconnectMode } from "./contracts";
@@ -104,9 +104,9 @@ const getCodeProposal =
 (quorum) => { var _a; return (_a = quorum.get("code")) !== null && _a !== void 0 ? _a : quorum.get("code2"); };
 export class Container extends EventEmitterWithErrorHandling {
     constructor(loader, config) {
-        var _a, _b;
+        var _a, _b, _c;
         super((name, error) => {
-            this.logger.sendErrorEvent({
+            this.mc.logger.sendErrorEvent({
                 eventName: "ContainerEventHandlerException",
                 name: typeof name === "string" ? name : undefined,
             }, error);
@@ -147,7 +147,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 containerLifecycleState: () => this._lifecycleState,
                 containerConnectionState: () => ConnectionState[this.connectionState],
             },
-            // we need to be judicious with our logging here to avoid generting too much data
+            // we need to be judicious with our logging here to avoid generating too much data
             // all data logged here should be broadly applicable, and not specific to a
             // specific error or class of errors
             error: {
@@ -160,12 +160,13 @@ export class Container extends EventEmitterWithErrorHandling {
                 dmLastMsqSeqNumber: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.sequenceNumber; },
                 dmLastMsqSeqTimestamp: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.timestamp; },
                 dmLastMsqSeqClientId: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.clientId; },
-                connectionState: () => ConnectionState[this.connectionState],
                 connectionStateDuration: () => performance.now() - this.connectionTransitionTimes[this.connectionState],
             },
         });
         // Prefix all events in this file with container-loader
-        this.logger = ChildLogger.create(this.subLogger, "Container");
+        this.mc = loggerToMonitoringContext(ChildLogger.create(this.subLogger, "Container"));
+        const summarizeProtocolTree = (_c = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree")) !== null && _c !== void 0 ? _c : this.loader.services.options.summarizeProtocolTree;
+        this.options = Object.assign(Object.assign({}, this.loader.services.options), { summarizeProtocolTree });
         this.connectionStateHandler = new ConnectionStateHandler({
             protocolHandler: () => this._protocolHandler,
             logConnectionStateChangeTelemetry: (value, oldState, reason) => this.logConnectionStateChangeTelemetry(value, oldState, reason),
@@ -184,14 +185,14 @@ export class Container extends EventEmitterWithErrorHandling {
                     this.propagateConnectionState();
                 }
             },
-        }, this.logger);
+        }, this.mc.logger);
         this._deltaManager = this.createDeltaManager();
         this._storage = new ContainerStorageAdapter(() => {
             if (this.attachState !== AttachState.Attached) {
                 if (this.loader.services.detachedBlobStorage !== undefined) {
-                    return new BlobOnlyStorage(this.loader.services.detachedBlobStorage, this.logger);
+                    return new BlobOnlyStorage(this.loader.services.detachedBlobStorage, this.mc.logger);
                 }
-                this.logger.sendErrorEvent({
+                this.mc.logger.sendErrorEvent({
                     eventName: "NoRealStorageInDetachedContainer",
                 });
                 throw new Error("Real storage calls not allowed in Unattached container");
@@ -205,7 +206,7 @@ export class Container extends EventEmitterWithErrorHandling {
         // keep track of last time page was visible for telemetry
         if (isDomAvailable) {
             this.lastVisible = document.hidden ? performance.now() : undefined;
-            document.addEventListener("visibilitychange", () => {
+            this.visibilityEventHandler = () => {
                 if (document.hidden) {
                     this.lastVisible = performance.now();
                 }
@@ -213,7 +214,8 @@ export class Container extends EventEmitterWithErrorHandling {
                     // settimeout so this will hopefully fire after disconnect event if being hidden caused it
                     setTimeout(() => this.lastVisible = undefined, 0);
                 }
-            });
+            };
+            document.addEventListener("visibilitychange", this.visibilityEventHandler);
         }
         // We observed that most users of platform do not check Container.connected event on load, causing bugs.
         // As such, we are raising events when new listener pops up.
@@ -246,7 +248,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     default:
                 }
             }).catch((error) => {
-                this.logger.sendErrorEvent({ eventName: "RaiseConnectedEventError" }, error);
+                this.mc.logger.sendErrorEvent({ eventName: "RaiseConnectedEventError" }, error);
             });
         });
     }
@@ -259,7 +261,7 @@ export class Container extends EventEmitterWithErrorHandling {
             resolvedUrl: loadOptions.resolvedUrl,
             canReconnect: loadOptions.canReconnect,
         });
-        return PerformanceEvent.timedExecAsync(container.logger, { eventName: "Load" }, async (event) => new Promise((res, rej) => {
+        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
             var _a;
             container._lifecycleState = "loading";
             const version = loadOptions.version;
@@ -269,7 +271,7 @@ export class Container extends EventEmitterWithErrorHandling {
             assert(pendingLocalState === undefined || loadOptions.loadMode === undefined, 0x1e1 /* "pending state requires immediate connection!" */);
             const mode = (_a = loadOptions.loadMode) !== null && _a !== void 0 ? _a : defaultMode;
             const onClosed = (err) => {
-                rej(err !== null && err !== void 0 ? err : new GenericError("containerClosedWithoutErrorDuringLoad"));
+                reject(err !== null && err !== void 0 ? err : new GenericError("containerClosedWithoutErrorDuringLoad"));
             };
             container.on("closed", onClosed);
             container.load(version, mode, pendingLocalState)
@@ -278,7 +280,7 @@ export class Container extends EventEmitterWithErrorHandling {
             })
                 .then((props) => {
                 event.end(Object.assign(Object.assign({}, props), loadOptions.loadMode));
-                res(container);
+                resolve(container);
             }, (error) => {
                 const err = normalizeError(error);
                 // Depending where error happens, we can be attempting to connect to web socket
@@ -294,7 +296,7 @@ export class Container extends EventEmitterWithErrorHandling {
      */
     static async createDetached(loader, codeDetails) {
         const container = new Container(loader, {});
-        return PerformanceEvent.timedExecAsync(container.logger, { eventName: "CreateDetached" }, async (_event) => {
+        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
             container._lifecycleState = "loading";
             await container.createDetached(codeDetails);
             return container;
@@ -306,7 +308,7 @@ export class Container extends EventEmitterWithErrorHandling {
      */
     static async rehydrateDetachedFromSnapshot(loader, snapshot) {
         const container = new Container(loader, {});
-        return PerformanceEvent.timedExecAsync(container.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
+        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
             const deserializedSummary = JSON.parse(snapshot);
             container._lifecycleState = "loading";
             await container.rehydrateDetachedFromSnapshot(deserializedSummary);
@@ -445,7 +447,6 @@ export class Container extends EventEmitterWithErrorHandling {
     }
     get serviceFactory() { return this.loader.services.documentServiceFactory; }
     get urlResolver() { return this.loader.services.urlResolver; }
-    get options() { return this.loader.services.options; }
     get scope() { return this.loader.services.scope; }
     get codeLoader() { return this.loader.services.codeLoader; }
     /**
@@ -475,14 +476,17 @@ export class Container extends EventEmitterWithErrorHandling {
                 (_d = this.service) === null || _d === void 0 ? void 0 : _d.dispose(error);
             }
             catch (exception) {
-                this.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
+                this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
             }
-            this.logger.sendTelemetryEvent({
+            this.mc.logger.sendTelemetryEvent({
                 eventName: "ContainerClose",
                 category: error === undefined ? "generic" : "error",
             }, error);
             this.emit("closed", error);
             this.removeAllListeners();
+            if (this.visibilityEventHandler !== undefined) {
+                document.removeEventListener("visibilitychange", this.visibilityEventHandler);
+            }
         }
         finally {
             this._lifecycleState = "closed";
@@ -515,7 +519,7 @@ export class Container extends EventEmitterWithErrorHandling {
         return JSON.stringify(combinedSummary);
     }
     async attach(request) {
-        await PerformanceEvent.timedExecAsync(this.logger, { eventName: "Attach" }, async () => {
+        await PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
             if (this._lifecycleState !== "loaded") {
                 throw new UsageError(`containerNotValidForAttach [${this._lifecycleState}]`);
             }
@@ -545,7 +549,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 const createNewResolvedUrl = await this.urlResolver.resolve(request);
                 ensureFluidResolvedUrl(createNewResolvedUrl);
                 if (this.service === undefined) {
-                    this.service = await runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger), "containerAttach", this.logger, {});
+                    this.service = await runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger), "containerAttach", this.mc.logger, {});
                 }
                 const resolvedUrl = this.service.resolvedUrl;
                 ensureFluidResolvedUrl(resolvedUrl);
@@ -599,12 +603,12 @@ export class Container extends EventEmitterWithErrorHandling {
         }, { start: true, end: true, cancel: "generic" });
     }
     async request(path) {
-        return PerformanceEvent.timedExecAsync(this.logger, { eventName: "Request" }, async () => this.context.request(path), { end: true, cancel: "error" });
+        return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => this.context.request(path), { end: true, cancel: "error" });
     }
     async snapshot(tagMessage, fullTree = false) {
         // Only snapshot once a code quorum has been established
         if (!this.protocolHandler.quorum.has("code") && !this.protocolHandler.quorum.has("code2")) {
-            this.logger.sendTelemetryEvent({ eventName: "SkipSnapshot" });
+            this.mc.logger.sendTelemetryEvent({ eventName: "SkipSnapshot" });
             return;
         }
         // Stop inbound message processing while we complete the snapshot
@@ -613,7 +617,7 @@ export class Container extends EventEmitterWithErrorHandling {
             await this.snapshotCore(tagMessage, fullTree);
         }
         catch (ex) {
-            this.logger.sendErrorEvent({ eventName: "SnapshotExceptionError" }, ex);
+            this.mc.logger.sendErrorEvent({ eventName: "SnapshotExceptionError" }, ex);
             throw ex;
         }
         finally {
@@ -632,7 +636,7 @@ export class Container extends EventEmitterWithErrorHandling {
         const now = performance.now();
         const duration = now - this.setAutoReconnectTime;
         this.setAutoReconnectTime = now;
-        this.logger.sendTelemetryEvent({
+        this.mc.logger.sendTelemetryEvent({
             eventName: reconnect ? "AutoReconnectEnabled" : "AutoReconnectDisabled",
             connectionMode: this.connectionMode,
             connectionState: ConnectionState[this.connectionState],
@@ -694,12 +698,12 @@ export class Container extends EventEmitterWithErrorHandling {
             throw new Error("Provided codeDetails are not IFluidCodeDetails");
         }
         if (this.codeLoader.IFluidCodeDetailsComparer) {
-            const comparision = await this.codeLoader.IFluidCodeDetailsComparer.compare(codeDetails, this.getCodeDetailsFromQuorum());
-            if (comparision !== undefined && comparision <= 0) {
+            const comparison = await this.codeLoader.IFluidCodeDetailsComparer.compare(codeDetails, this.getCodeDetailsFromQuorum());
+            if (comparison !== undefined && comparison <= 0) {
                 throw new Error("Proposed code details should be greater than the current");
             }
         }
-        return this.getQuorum().propose("code", codeDetails)
+        return this.protocolHandler.quorum.propose("code", codeDetails)
             .then(() => true)
             .catch(() => false);
     }
@@ -954,8 +958,9 @@ export class Container extends EventEmitterWithErrorHandling {
         assert(this.service !== undefined, 0x1ef /* "services must be defined" */);
         const storageService = await this.service.connectToStorage();
         this._storageService =
-            new RetriableDocumentStorageService(storageService, this.logger);
+            new RetriableDocumentStorageService(storageService, this.mc.logger);
         if (this.options.summarizeProtocolTree === true) {
+            this.mc.logger.sendTelemetryEvent({ eventName: "summarizeProtocolTreeEnabled" });
             this._storageService =
                 new ProtocolTreeStorageService(this._storageService, () => this.captureProtocolSummary());
         }
@@ -1017,7 +1022,7 @@ export class Container extends EventEmitterWithErrorHandling {
         protocol.quorum.on("approveProposal", (sequenceNumber, key, value) => {
             if (key === "code" || key === "code2") {
                 if (!isFluidCodeDetails(value)) {
-                    this.logger.sendErrorEvent({
+                    this.mc.logger.sendErrorEvent({
                         eventName: "CodeProposalNotIFluidCodeDetails",
                     });
                 }
@@ -1171,7 +1176,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 connectionInitiationReason = "AutoReconnect";
             }
         }
-        this.logger.sendPerformanceEvent(Object.assign({ eventName: `ConnectionStateChange_${ConnectionState[value]}`, from: ConnectionState[oldState], duration,
+        this.mc.logger.sendPerformanceEvent(Object.assign({ eventName: `ConnectionStateChange_${ConnectionState[value]}`, from: ConnectionState[oldState], duration,
             durationFromDisconnected,
             reason,
             connectionInitiationReason, pendingClientId: this.connectionStateHandler.pendingClientId, clientId: this.clientId, autoReconnect,
@@ -1194,9 +1199,9 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         assert(this.protocolHandler !== undefined, 0x0dc /* "Protocol handler should be set here" */);
         this.protocolHandler.quorum.setConnectionState(state, this.clientId);
-        raiseConnectedEvent(this.logger, this, state, this.clientId);
+        raiseConnectedEvent(this.mc.logger, this, state, this.clientId);
         if (logOpsOnReconnect) {
-            this.logger.sendTelemetryEvent({ eventName: "OpsSentOnReconnect", count: this.messageCountAfterDisconnection });
+            this.mc.logger.sendTelemetryEvent({ eventName: "OpsSentOnReconnect", count: this.messageCountAfterDisconnection });
         }
     }
     submitContainerMessage(type, contents, batch, metadata) {
@@ -1226,7 +1231,7 @@ export class Container extends EventEmitterWithErrorHandling {
     }
     submitMessage(type, contents, batch, metadata) {
         if (this.connectionState !== ConnectionState.Connected) {
-            this.logger.sendErrorEvent({ eventName: "SubmitMessageWithNoConnection", type });
+            this.mc.logger.sendErrorEvent({ eventName: "SubmitMessageWithNoConnection", type });
             return -1;
         }
         this.messageCountAfterDisconnection += 1;
@@ -1292,12 +1297,12 @@ export class Container extends EventEmitterWithErrorHandling {
         const version = await this.getVersion(specifiedVersion !== null && specifiedVersion !== void 0 ? specifiedVersion : this.id);
         if (version === undefined && specifiedVersion !== undefined) {
             // We should have a defined version to load from if specified version requested
-            this.logger.sendErrorEvent({ eventName: "NoVersionFoundWhenSpecified", id: specifiedVersion });
+            this.mc.logger.sendErrorEvent({ eventName: "NoVersionFoundWhenSpecified", id: specifiedVersion });
         }
         this._loadedFromVersion = version;
         const snapshot = (_a = await this.storageService.getSnapshotTree(version)) !== null && _a !== void 0 ? _a : undefined;
         if (snapshot === undefined && version !== undefined) {
-            this.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
+            this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
         }
         return { snapshot, versionId: version === null || version === void 0 ? void 0 : version.id };
     }
@@ -1313,7 +1318,7 @@ export class Container extends EventEmitterWithErrorHandling {
         assert(((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) !== false, 0x0dd /* "Existing context not disposed" */);
         // If this assert fires, our state tracking is likely not synchronized between COntainer & runtime.
         if (this._dirtyContainer) {
-            this.logger.sendErrorEvent({ eventName: "DirtyContainerReloadContainer" });
+            this.mc.logger.sendErrorEvent({ eventName: "DirtyContainerReloadContainer" });
         }
         // The relative loader will proxy requests to '/' to the loader itself assuming no non-cache flags
         // are set. Global requests will still go directly to the loader
@@ -1327,7 +1332,7 @@ export class Container extends EventEmitterWithErrorHandling {
     // Please avoid calling it directly.
     // raiseContainerWarning() is the right flow for most cases
     logContainerError(warning) {
-        this.logger.sendErrorEvent({ eventName: "ContainerWarning" }, warning);
+        this.mc.logger.sendErrorEvent({ eventName: "ContainerWarning" }, warning);
     }
 }
 Container.version = "^0.1.0";