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

package/dist/summary/summarizerNode/summarizerNode.js

@@ -8,7 +8,7 @@ exports.createRootSummarizerNode = exports.SummarizerNode = void 0;
 const runtime_definitions_1 = require("@fluidframework/runtime-definitions");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
-const common_utils_1 = require("@fluidframework/common-utils");
+const core_utils_1 = require("@fluidframework/core-utils");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
 const summarizerNodeUtils_1 = require("./summarizerNodeUtils");
 /**
@@ -34,7 +34,6 @@ class SummarizerNode {
     _latestSummary, initialSummary, wipSummaryLogger, 
     /** A unique id of this node to be logged when sending telemetry. */
     telemetryNodeId) {
-        var _a;
         this.summarizeInternalFn = summarizeInternalFn;
         this._changeSequenceNumber = _changeSequenceNumber;
         this._latestSummary = _latestSummary;
@@ -44,14 +43,12 @@ class SummarizerNode {
         this.children = new Map();
         this.pendingSummaries = new Map();
         this.wipSkipRecursion = false;
-        this.canReuseHandle = (_a = config.canReuseHandle) !== null && _a !== void 0 ? _a : true;
+        this.canReuseHandle = config.canReuseHandle ?? true;
         // All logs posted by the summarizer node should include the telemetryNodeId.
-        this.logger = telemetry_utils_1.ChildLogger.create(baseLogger, undefined /* namespace */, {
-            all: {
-                id: {
-                    tag: telemetry_utils_1.TelemetryDataTag.CodeArtifact,
-                    value: this.telemetryNodeId,
-                },
+        this.logger = (0, telemetry_utils_1.createChildLogger)({
+            logger: baseLogger,
+            properties: {
+                all: (0, telemetry_utils_1.tagCodeArtifacts)({ id: this.telemetryNodeId }),
             },
         });
     }
@@ -60,12 +57,11 @@ class SummarizerNode {
      * Returns 0 if there is not yet an acked summary.
      */
     get referenceSequenceNumber() {
-        var _a, _b;
-        return (_b = (_a = this._latestSummary) === null || _a === void 0 ? void 0 : _a.referenceSequenceNumber) !== null && _b !== void 0 ? _b : 0;
+        return this._latestSummary?.referenceSequenceNumber ?? 0;
     }
     startSummary(referenceSequenceNumber, summaryLogger) {
-        (0, common_utils_1.assert)(this.wipSummaryLogger === undefined, 0x19f /* "wipSummaryLogger should not be set yet in startSummary" */);
-        (0, common_utils_1.assert)(this.wipReferenceSequenceNumber === undefined, 0x1a0 /* "Already tracking a summary" */);
+        (0, core_utils_1.assert)(this.wipSummaryLogger === undefined, 0x19f /* "wipSummaryLogger should not be set yet in startSummary" */);
+        (0, core_utils_1.assert)(this.wipReferenceSequenceNumber === undefined, 0x1a0 /* "Already tracking a summary" */);
         this.wipSummaryLogger = summaryLogger;
         for (const child of this.children.values()) {
             child.startSummary(referenceSequenceNumber, this.wipSummaryLogger);
@@ -73,8 +69,8 @@ class SummarizerNode {
         this.wipReferenceSequenceNumber = referenceSequenceNumber;
     }
     async summarize(fullTree, trackState = true, telemetryContext) {
-        (0, common_utils_1.assert)(this.isSummaryInProgress(), 0x1a1 /* "summarize should not be called when not tracking the summary" */);
-        (0, common_utils_1.assert)(this.wipSummaryLogger !== undefined, 0x1a2 /* "wipSummaryLogger should have been set in startSummary or ctor" */);
+        (0, core_utils_1.assert)(this.isSummaryInProgress(), 0x1a1 /* "summarize should not be called when not tracking the summary" */);
+        (0, core_utils_1.assert)(this.wipSummaryLogger !== undefined, 0x1a2 /* "wipSummaryLogger should have been set in startSummary or ctor" */);
         // Try to reuse the tree if unchanged
         if (this.canReuseHandle && !fullTree && !this.hasChanged()) {
             const latestSummary = this._latestSummary;
@@ -98,7 +94,7 @@ class SummarizerNode {
         }
         // This assert is the same the other 0a1x1 assert `isSummaryInProgress`, the only difference is that typescript
         // complains if this assert isn't done this way
-        (0, common_utils_1.assert)(this.wipReferenceSequenceNumber !== undefined, 0x5df /* Summarize should not be called when not tracking the summary */);
+        (0, core_utils_1.assert)(this.wipReferenceSequenceNumber !== undefined, 0x5df /* Summarize should not be called when not tracking the summary */);
         const incrementalSummaryContext = this._latestSummary !== undefined
             ? {
                 summarySequenceNumber: this.wipReferenceSequenceNumber,
@@ -115,17 +111,97 @@ class SummarizerNode {
         return { summary: result.summary, stats: result.stats };
     }
     /**
-     * Complete the WIP summary for the given proposalHandle
+     * Validates that the in-progress summary is correct, i.e., summarize should have run for all non-skipped
+     * nodes. This will only be called for the root summarizer node and is called by it recursively on all child nodes.
+     *
+     * @returns ValidateSummaryResult which contains a boolean success indicating whether the validation was successful.
+     * In case of failure, additional information is returned indicating type of failure and where it was.
      */
-    completeSummary(proposalHandle) {
-        this.completeSummaryCore(proposalHandle, undefined, false);
+    validateSummary() {
+        return this.validateSummaryCore(false /* parentSkipRecursion */);
     }
     /**
-     * Recursive implementation for completeSummary, with additional internal-only parameters
+     * Validates that the in-progress summary is correct for all nodes, i.e., summarize should have run for all
+     * non-skipped nodes.
+     * @param parentSkipRecursion - true if the parent of this node skipped recursing the child nodes when summarizing.
+     * In that case, the children will not have work-in-progress state.
+     *
+     * @returns ValidateSummaryResult which contains a boolean success indicating whether the validation was successful.
+     * In case of failure, additional information is returned indicating type of failure and where it was.
      */
-    completeSummaryCore(proposalHandle, parentPath, parentSkipRecursion) {
-        (0, common_utils_1.assert)(this.wipSummaryLogger !== undefined, 0x1a3 /* "wipSummaryLogger should have been set in startSummary or ctor" */);
-        (0, common_utils_1.assert)(this.wipReferenceSequenceNumber !== undefined, 0x1a4 /* "Not tracking a summary" */);
+    validateSummaryCore(parentSkipRecursion) {
+        if (this.wasSummarizeMissed(parentSkipRecursion)) {
+            return {
+                success: false,
+                reason: "NodeDidNotSummarize",
+                id: {
+                    tag: telemetry_utils_1.TelemetryDataTag.CodeArtifact,
+                    value: this.telemetryNodeId,
+                },
+                // These errors are usually transient and should go away when summarize is retried.
+                retryAfterSeconds: 1,
+            };
+        }
+        if (parentSkipRecursion) {
+            return { success: true };
+        }
+        for (const child of this.children.values()) {
+            const result = child.validateSummaryCore(this.wipSkipRecursion || parentSkipRecursion);
+            // If any child fails, return the failure.
+            if (!result.success) {
+                return result;
+            }
+        }
+        return { success: true };
+    }
+    wasSummarizeMissed(parentSkipRecursion) {
+        (0, core_utils_1.assert)(this.wipSummaryLogger !== undefined, 0x6fc /* wipSummaryLogger should have been set in startSummary or ctor */);
+        (0, core_utils_1.assert)(this.wipReferenceSequenceNumber !== undefined, 0x6fd /* Not tracking a summary */);
+        // If the parent node skipped recursion, it did not call summarize on this node. So, summarize was not missed
+        // but was intentionally not called.
+        // Otherwise, summarize should have been called on this node and wipLocalPaths must be set.
+        if (parentSkipRecursion || this.wipLocalPaths !== undefined) {
+            return false;
+        }
+        /**
+         * The absence of wip local path indicates that summarize was not called for this node. Return failure.
+         * This can happen if:
+         * 1. A child node was created after summarize was already called on the parent. For example, a data store
+         * is realized (loaded) after summarize was called on it creating summarizer nodes for its DDSes. In this case,
+         * parentSkipRecursion will be true and the if block above would handle it.
+         * 2. A new node was created but summarize was never called on it. This can mean that the summary that is
+         * generated may not have the data from this node. We should not continue, log and throw an error. This
+         * will help us identify these cases and take appropriate action.
+         *
+         * This happens due to scenarios such as data store created during summarize. Such errors should go away when
+         * summarize is attempted again.
+         */
+        return true;
+    }
+    /**
+     * Called after summary has been uploaded to the server. Add the work-in-progress state to the pending summary
+     * queue. We track this until we get an ack from the server for this summary.
+     * @param proposalHandle - The handle of the summary that was uploaded to the server.
+     */
+    completeSummary(proposalHandle, validate) {
+        this.completeSummaryCore(proposalHandle, undefined /* parentPath */, false /* parentSkipRecursion */, validate);
+    }
+    /**
+     * Recursive implementation for completeSummary, with additional internal-only parameters.
+     * @param proposalHandle - The handle of the summary that was uploaded to the server.
+     * @param parentPath - The path of the parent node which is used to build the path of this node.
+     * @param parentSkipRecursion - true if the parent of this node skipped recursing the child nodes when summarizing.
+     * In that case, the children will not have work-in-progress state.
+     * @param validate - true to validate that the in-progress summary is correct for all nodes.
+     */
+    completeSummaryCore(proposalHandle, parentPath, parentSkipRecursion, validate) {
+        if (validate && this.wasSummarizeMissed(parentSkipRecursion)) {
+            this.throwUnexpectedError({
+                eventName: "NodeDidNotSummarize",
+                proposalHandle,
+            });
+        }
+        (0, core_utils_1.assert)(this.wipReferenceSequenceNumber !== undefined, 0x1a4 /* "Not tracking a summary" */);
         let localPathsToUse = this.wipLocalPaths;
         if (parentSkipRecursion) {
             const latestSummary = this._latestSummary;
@@ -152,25 +228,17 @@ class SummarizerNode {
                 return;
             }
         }
-        /**
-         * The absence of wip local path indicates that summarize was not called for this node. This can happen if:
-         * 1. A child node was created after summarize was already called on the parent. For example, a data store
-         * is realized (loaded) after summarize was called on it creating summarizer nodes for its DDSes. In this case,
-         * parentSkipRecursion will be true and the if block above would handle it.
-         * 2. A new node was created but summarize was never called on it. This can mean that the summary that is
-         * generated may not have the data from this node. We should not continue, log and throw an error. This
-         * will help us identify these cases and take appropriate action.
-         */
-        if (localPathsToUse === undefined) {
-            this.throwUnexpectedError({
-                eventName: "NodeNotSummarized",
-                proposalHandle,
-            });
-        }
-        const summary = new summarizerNodeUtils_1.SummaryNode(Object.assign(Object.assign({}, localPathsToUse), { referenceSequenceNumber: this.wipReferenceSequenceNumber, basePath: parentPath }));
+        // If localPathsToUse is undefined, it means summarize didn't run for this node and in that case the validate
+        // step should have failed.
+        (0, core_utils_1.assert)(localPathsToUse !== undefined, 0x6fe /* summarize didn't run for node */);
+        const summary = new summarizerNodeUtils_1.SummaryNode({
+            ...localPathsToUse,
+            referenceSequenceNumber: this.wipReferenceSequenceNumber,
+            basePath: parentPath,
+        });
         const fullPathForChildren = summary.fullPathForChildren;
         for (const child of this.children.values()) {
-            child.completeSummaryCore(proposalHandle, fullPathForChildren, this.wipSkipRecursion || parentSkipRecursion);
+            child.completeSummaryCore(proposalHandle, fullPathForChildren, this.wipSkipRecursion || parentSkipRecursion, validate);
         }
         // Note that this overwrites existing pending summary with
         // the same proposalHandle. If proposalHandle is something like
@@ -192,26 +260,21 @@ class SummarizerNode {
     }
     /**
      * Refreshes the latest summary tracked by this node. If we have a pending summary for the given proposal handle,
-     * it becomes the latest summary. If the current summary is already ahead (e.g., loaded from a service summary),
-     * we skip the update. Otherwise, we fetch the latest snapshot and update latest summary based off of that.
-     *
-     * @returns A RefreshSummaryResult type which returns information based on the following three scenarios:
-     *
-     * 1. The latest summary was not updated.
+     * it becomes the latest summary. If the current summary is already ahead, we skip the update.
+     * If the current summary is behind, then we do not refresh.
      *
-     * 2. The latest summary was updated and the summary corresponding to the params was being tracked.
-     *
-     * 3. The latest summary was updated but the summary corresponding to the params was not tracked. In this
-     * case, the latest summary is updated based on the downloaded snapshot which is also returned.
+     * @returns true if the summary is tracked by this node, false otherwise.
      */
-    async refreshLatestSummary(proposalHandle, summaryRefSeq, fetchLatestSnapshot, readAndParseBlob, correlatedSummaryLogger) {
+    async refreshLatestSummary(proposalHandle, summaryRefSeq) {
         const eventProps = {
             proposalHandle,
             summaryRefSeq,
             referenceSequenceNumber: this.referenceSequenceNumber,
         };
-        return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.logger, Object.assign({ eventName: "refreshLatestSummary" }, eventProps), async (event) => {
-            var _a;
+        return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.logger, {
+            eventName: "refreshLatestSummary",
+            ...eventProps,
+        }, async (event) => {
             // Refresh latest summary should not happen while a summary is in progress. If it does, it can result
             // in inconsistent state, so, we should not continue;
             if (this.isSummaryInProgress()) {
@@ -219,57 +282,18 @@ class SummarizerNode {
                     inProgressSummaryRefSeq: this.wipReferenceSequenceNumber,
                 });
             }
-            if (proposalHandle !== undefined) {
-                const maybeSummaryNode = this.pendingSummaries.get(proposalHandle);
-                if (maybeSummaryNode !== undefined) {
-                    this.refreshLatestSummaryFromPending(proposalHandle, maybeSummaryNode.referenceSequenceNumber);
-                    eventProps.wasSummaryTracked = true;
-                    eventProps.latestSummaryUpdated = true;
-                    event.end(eventProps);
-                    return {
-                        latestSummaryUpdated: true,
-                        wasSummaryTracked: true,
-                        summaryRefSeq,
-                    };
-                }
-                const props = {
-                    summaryRefSeq,
-                    pendingSize: (_a = this.pendingSummaries.size) !== null && _a !== void 0 ? _a : undefined,
-                };
-                this.logger.sendTelemetryEvent({
-                    eventName: "PendingSummaryNotFound",
-                    proposalHandle,
-                    referenceSequenceNumber: this.referenceSequenceNumber,
-                    details: JSON.stringify(props),
-                });
+            let isSummaryTracked = false;
+            let isSummaryNewer = false;
+            if (summaryRefSeq > this.referenceSequenceNumber) {
+                isSummaryNewer = true;
             }
-            // If the summary for which refresh is called is older than the latest tracked summary, ignore it.
-            if (this.referenceSequenceNumber >= summaryRefSeq) {
-                eventProps.latestSummaryUpdated = false;
-                event.end(eventProps);
-                return { latestSummaryUpdated: false };
+            const maybeSummaryNode = this.pendingSummaries.get(proposalHandle);
+            if (maybeSummaryNode !== undefined) {
+                this.refreshLatestSummaryFromPending(proposalHandle, maybeSummaryNode.referenceSequenceNumber);
+                isSummaryTracked = true;
             }
-            // Fetch the latest snapshot and refresh state from it. Note that we need to use the reference sequence number
-            // of the fetched snapshot and not the "summaryRefSeq" that was passed in.
-            const { snapshotTree, snapshotRefSeq: fetchedSnapshotRefSeq } = await fetchLatestSnapshot();
-            // Possible re-entrancy. We may have updated latest summary state while fetching the snapshot. If the fetched
-            // snapshot is older than the latest tracked summary, ignore it.
-            if (this.referenceSequenceNumber >= fetchedSnapshotRefSeq) {
-                eventProps.latestSummaryUpdated = false;
-                event.end(eventProps);
-                return { latestSummaryUpdated: false };
-            }
-            await this.refreshLatestSummaryFromSnapshot(fetchedSnapshotRefSeq, snapshotTree, undefined, summarizerNodeUtils_1.EscapedPath.create(""), correlatedSummaryLogger, readAndParseBlob);
-            eventProps.latestSummaryUpdated = true;
-            eventProps.wasSummaryTracked = false;
-            eventProps.summaryRefSeq = fetchedSnapshotRefSeq;
-            event.end(eventProps);
-            return {
-                latestSummaryUpdated: true,
-                wasSummaryTracked: false,
-                snapshotTree,
-                summaryRefSeq: fetchedSnapshotRefSeq,
-            };
+            event.end({ ...eventProps, isSummaryNewer, pendingSummaryFound: isSummaryTracked });
+            return { isSummaryTracked, isSummaryNewer };
         }, { start: true, end: true, cancel: "error" });
     }
     /**
@@ -282,11 +306,11 @@ class SummarizerNode {
         const summaryNode = this.pendingSummaries.get(proposalHandle);
         if (summaryNode === undefined) {
             // This should only happen if parent skipped recursion AND no prior summary existed.
-            (0, common_utils_1.assert)(this._latestSummary === undefined, 0x1a6 /* "Not found pending summary, but this node has previously completed a summary" */);
+            (0, core_utils_1.assert)(this._latestSummary === undefined, 0x1a6 /* "Not found pending summary, but this node has previously completed a summary" */);
             return;
         }
         else {
-            (0, common_utils_1.assert)(referenceSequenceNumber === summaryNode.referenceSequenceNumber, 0x1a7 /* Pending summary reference sequence number should be consistent */);
+            (0, core_utils_1.assert)(referenceSequenceNumber === summaryNode.referenceSequenceNumber, 0x1a7 /* Pending summary reference sequence number should be consistent */);
             // Clear earlier pending summaries
             this.pendingSummaries.delete(proposalHandle);
         }
@@ -297,37 +321,6 @@ class SummarizerNode {
             child.refreshLatestSummaryFromPending(proposalHandle, referenceSequenceNumber);
         }
     }
-    async refreshLatestSummaryFromSnapshot(referenceSequenceNumber, snapshotTree, basePath, localPath, correlatedSummaryLogger, readAndParseBlob) {
-        // Possible re-entrancy. If we have already seen a summary later than this one, ignore it.
-        if (this.referenceSequenceNumber >= referenceSequenceNumber) {
-            return;
-        }
-        this.refreshLatestSummaryCore(referenceSequenceNumber);
-        this._latestSummary = new summarizerNodeUtils_1.SummaryNode({
-            referenceSequenceNumber,
-            basePath,
-            localPath,
-        });
-        const pathParts = [];
-        const { childrenTree, childrenPathPart } = (0, summarizerNodeUtils_1.parseSummaryForSubtrees)(snapshotTree);
-        if (childrenPathPart !== undefined) {
-            pathParts.push(childrenPathPart);
-        }
-        if (pathParts.length > 0) {
-            this._latestSummary.additionalPath = summarizerNodeUtils_1.EscapedPath.createAndConcat(pathParts);
-        }
-        // Propagate update to all child nodes
-        const pathForChildren = this._latestSummary.fullPathForChildren;
-        await Promise.all(Array.from(this.children)
-            .filter(([id]) => {
-            // Assuming subtrees missing from snapshot are newer than the snapshot,
-            // but might be nice to assert this using earliest seq for node.
-            return childrenTree.trees[id] !== undefined;
-        })
-            .map(async ([id, child]) => {
-            return child.refreshLatestSummaryFromSnapshot(referenceSequenceNumber, childrenTree.trees[id], pathForChildren, summarizerNodeUtils_1.EscapedPath.create(id), correlatedSummaryLogger, readAndParseBlob);
-        }));
-    }
     refreshLatestSummaryCore(referenceSequenceNumber) {
         for (const [key, value] of this.pendingSummaries) {
             if (value.referenceSequenceNumber < referenceSequenceNumber) {
@@ -373,7 +366,7 @@ class SummarizerNode {
      * Attach information if it is created from an attach op.
      */
     createParam, config = {}) {
-        (0, common_utils_1.assert)(!this.children.has(id), 0x1ab /* "Create SummarizerNode child already exists" */);
+        (0, core_utils_1.assert)(!this.children.has(id), 0x1ab /* "Create SummarizerNode child already exists" */);
         const createDetails = this.getCreateDetailsForChild(id, createParam);
         const child = new SummarizerNode(this.logger, summarizeInternalFn, config, createDetails.changeSequenceNumber, createDetails.latestSummary, createDetails.initialSummary, this.wipSummaryLogger, createDetails.telemetryNodeId);
         // There may be additional state that has to be updated in this child. For example, if a summary is being
@@ -393,7 +386,6 @@ class SummarizerNode {
      * @returns the details needed to create the child node.
      */
     getCreateDetailsForChild(id, createParam) {
-        var _a, _b;
         let initialSummary;
         let latestSummary;
         let changeSequenceNumber;
@@ -418,7 +410,7 @@ class SummarizerNode {
             }
             case runtime_definitions_1.CreateSummarizerNodeSource.FromSummary: {
                 if (this.initialSummary === undefined) {
-                    (0, common_utils_1.assert)(!!parentLatestSummary, 0x1ac /* "Cannot create child from summary if parent does not have latest summary" */);
+                    (0, core_utils_1.assert)(!!parentLatestSummary, 0x1ac /* "Cannot create child from summary if parent does not have latest summary" */);
                 }
                 // fallthrough to local
             }
@@ -428,16 +420,16 @@ class SummarizerNode {
                     let childSummary;
                     if (parentInitialSummary.summary !== undefined) {
                         const { childrenTree } = (0, summarizerNodeUtils_1.parseSummaryTreeForSubtrees)(parentInitialSummary.summary.summary);
-                        (0, common_utils_1.assert)(childrenTree.type === protocol_definitions_1.SummaryType.Tree, 0x1d6 /* "Parent summary object is not a tree" */);
+                        (0, core_utils_1.assert)(childrenTree.type === protocol_definitions_1.SummaryType.Tree, 0x1d6 /* "Parent summary object is not a tree" */);
                         childSummary = childrenTree.tree[id];
                     }
                     if (createParam.type === runtime_definitions_1.CreateSummarizerNodeSource.FromSummary) {
                         // Locally created would not have differential subtree.
-                        (0, common_utils_1.assert)(!!childSummary, 0x1ad /* "Missing child summary tree" */);
+                        (0, core_utils_1.assert)(!!childSummary, 0x1ad /* "Missing child summary tree" */);
                     }
                     let childSummaryWithStats;
                     if (childSummary !== undefined) {
-                        (0, common_utils_1.assert)(childSummary.type === protocol_definitions_1.SummaryType.Tree, 0x1ae /* "Child summary object is not a tree" */);
+                        (0, core_utils_1.assert)(childSummary.type === protocol_definitions_1.SummaryType.Tree, 0x1ae /* "Child summary object is not a tree" */);
                         childSummaryWithStats = {
                             summary: childSummary,
                             stats: (0, runtime_utils_1.calculateStats)(childSummary),
@@ -449,16 +441,16 @@ class SummarizerNode {
                         summary: childSummaryWithStats,
                     };
                 }
-                latestSummary = parentLatestSummary === null || parentLatestSummary === void 0 ? void 0 : parentLatestSummary.createForChild(id);
-                changeSequenceNumber = (_a = parentLatestSummary === null || parentLatestSummary === void 0 ? void 0 : parentLatestSummary.referenceSequenceNumber) !== null && _a !== void 0 ? _a : -1;
+                latestSummary = parentLatestSummary?.createForChild(id);
+                changeSequenceNumber = parentLatestSummary?.referenceSequenceNumber ?? -1;
                 break;
             }
             default: {
                 const type = createParam.type;
-                (0, common_utils_1.unreachableCase)(createParam, `Unexpected CreateSummarizerNodeSource: ${type}`);
+                (0, core_utils_1.unreachableCase)(createParam, `Unexpected CreateSummarizerNodeSource: ${type}`);
             }
         }
-        const childtelemetryNodeId = `${(_b = this.telemetryNodeId) !== null && _b !== void 0 ? _b : ""}/${id}`;
+        const childtelemetryNodeId = `${this.telemetryNodeId ?? ""}/${id}`;
         return {
             initialSummary,
             latestSummary,
@@ -506,10 +498,13 @@ class SummarizerNode {
      * Creates and throws an error due to unexpected conditions.
      */
     throwUnexpectedError(eventProps) {
-        const error = new telemetry_utils_1.LoggingError(eventProps.eventName, Object.assign(Object.assign({}, eventProps), { referenceSequenceNumber: this.wipReferenceSequenceNumber, id: {
-                tag: telemetry_utils_1.TelemetryDataTag.CodeArtifact,
-                value: this.telemetryNodeId,
-            } }));
+        const error = new telemetry_utils_1.LoggingError(eventProps.eventName, {
+            ...eventProps,
+            referenceSequenceNumber: this.wipReferenceSequenceNumber,
+            ...(0, telemetry_utils_1.tagCodeArtifacts)({
+                id: this.telemetryNodeId,
+            }),
+        });
         this.logger.sendErrorEvent(eventProps, error);
         throw error;
     }